dummy-link

FastRounding

Faster directed rounding for inline arithmetic

Readme

FastRounding.jl

Faster directed rounding for inline arithmetic

Copyright © 2015-2018 by Jeffrey Sarnoff. Released under the MIT License.


Build Status


Quick Overview

  • This package provides arithmetic with directed rounding

  • The numeric types
    { Float32, Float64 }

  • The arithmetic operations { +, -, *, inv, /, sqrt }

  • The directed rounding modes
    { RoundNearest, RoundUp, RoundDown, RoundToZero, RoundFromZero }

  • These functions ran faster than Julia's erstwhile setrounding


Rounding Modes

  • RoundNearest
  • RoundUp
  • RoundDown
  • RoundToZero
  • RoundFromZero

Exports

  • add_round, sub_round
  • square_round, mul_round
  • sqrt_round, inv_round
  • div_round

Equivalent Exports

subscript signifies mode
◌₌ RoundNearest
◌₊ RoundUp
◌₋ RoundDown
◌₀ RoundToZero
◌₁ RoundFromZero

unicode op arithmetic op
+
-
*
inv
/
square
sqrt

Use

julia> using FastRounding

julia> a = Float32(pi)
3.1415927f0

julia> b = inv(Float32(pi))
0.31830987f0

julia> mul_round(a, b, RoundUp)
1.0f0

julia> mul_round(a, b, RoundNearest)
1.0f0

julia> mul_round(a, b, RoundDown)
0.99999994f0

julia> mul_round(a, b, RoundToZero)
0.99999994f0

julia> mul_round(a, b, RoundFromZero)
1.0f0

julia> two = Float64(2)
2.0

julia> sqrt_round(two, RoundUp)
1.4142135623730951

julia> sqrt_round(two, RoundNearest)
1.4142135623730951

julia> sqrt_round(two, RoundDown)
1.414213562373095

julia> inv_round(-two, RoundToZero)
-0.5

julia> inv_round(-two, RoundFromZero)
-0.5000000000000001

julia> ⊙₋(two)  # sqrt(2) rounding down
1.414213562373095

julia> two ⊘₁ ans  # 2 / (sqrt(2) rounding down) rounding away from zero
1.4142135623730954

Conformance

These functions conform to the requirements of the IEEE Interval Floating Point Standard for directed rounding, passing their tests as implemented in IntervalArithmetic.jl.

While not required by the IEEE Floating Point Standard, RoundToZero and RoundFromZero modes exist.

The determination of last bit(s) is correct to twice the significance of the rounded value. We do not provide the equivalent of infinitly precise evaluation when at doubled the given precision, all least significant bits are zero. We are accurate and fast.

If you require that RoundUp, RoundDown pairs assure enclosure of the theoretical result at a precision that exceeds 106 bits when working with Float64s (which have 53 significant bits), please let me know. I could force nextfloat and prevfloat calls in those cases, forgoing the tightest results for the most inclusive. Those routines run a little slower than these. Note that those routines may not match the Standard test suite values in those adjusted cases.

First Commit

03/28/2016

Last Touched

3 months ago

Commits

241 commits