Normalization and rounding

The PR replaces `round` and `normalize`.

Fixes #27
Fixes #36
Fixes #39
Fixes #50

src/Decimals.jl

@@ -24,26 +24,13 @@ end
 
 include("bigint.jl")
 include("context.jl")
-
-# Convert between Decimal objects, numbers, and strings
+include("conversion.jl")
 include("decimal.jl")
-
-# Decimal normalization
-include("norm.jl")
-
-# Addition, subtraction, negation, multiplication
 include("arithmetic.jl")
-
-# Equality
 include("equals.jl")
-
-# Rounding
 include("round.jl")
-
 include("hash.jl")
-
 include("parse.jl")
-
 include("show.jl")
 
 end

src/conversion.jl

@@ -0,0 +1,47 @@
+Decimal(x::Decimal) = x
+Decimal(n::Integer) = Decimal(signbit(n), abs(n), 0)
+function Decimal(x::AbstractFloat)
+    if !isfinite(x)
+        throw(ArgumentError("$x cannot be represented as a Decimal"))
+    end
+
+    # Express `x` as a rational `u = n / 2^k`, where `k ≥ 0`
+    u = Rational(abs(x))
+
+    # u.den = 2^k
+    k = ndigits(u.den, base=2) - 1
+
+    # We can write
+    #
+    #   x = n / 2^k
+    #     = n / 2^k * 10^k * 10^-k
+    #     = (n * 10^k / 2^k) * 10^-k
+    #     = (n * 5^k) * 10^-k
+
+    s = signbit(x)
+    c = u.num * BigInt(5)^k
+    q = -k
+    return Decimal(s, c, q)
+end
+
+Base.convert(::Type{Decimal}, x::Real) = Decimal(x)
+
+function Base.BigFloat(x::Decimal)
+    y = BigFloat(x.c)
+    if x.q ≥ 0
+        y *= BigTen^x.q
+    else
+        y /= BigTen^(-x.q)
+    end
+    return x.s ? -y : y
+end
+
+(::Type{T})(x::Decimal) where {T<:Number} = T(BigFloat(x))
+
+# String representation of Decimal
+function Base.string(x::Decimal)
+    io = IOBuffer()
+    scientific_notation(io, x)
+    return String(take!(io))
+end
+

src/decimal.jl

@@ -1,50 +1,3 @@
-Decimal(x::Decimal) = x
-Decimal(n::Integer) = Decimal(signbit(n), abs(n), 0)
-function Decimal(x::AbstractFloat)
-    if !isfinite(x)
-        throw(ArgumentError("$x cannot be represented as a Decimal"))
-    end
-
-    # Express `x` as a rational `u = n / 2^k`, where `k ≥ 0`
-    u = Rational(abs(x))
-
-    # u.den = 2^k
-    k = ndigits(u.den, base=2) - 1
-
-    # We can write
-    #
-    #   x = n / 2^k
-    #     = n / 2^k * 10^k * 10^-k
-    #     = (n * 10^k / 2^k) * 10^-k
-    #     = (n * 5^k) * 10^-k
-
-    s = signbit(x)
-    c = u.num * BigInt(5)^k
-    q = -k
-    return Decimal(s, c, q)
-end
-
-Base.convert(::Type{Decimal}, x::Real) = Decimal(x)
-
-function Base.BigFloat(x::Decimal)
-    y = BigFloat(x.c)
-    if x.q ≥ 0
-        y *= BigTen^x.q
-    else
-        y /= BigTen^(-x.q)
-    end
-    return x.s ? -y : y
-end
-
-(::Type{T})(x::Decimal) where {T<:Number} = T(BigFloat(x))
-
-# String representation of Decimal
-function Base.string(x::Decimal)
-    io = IOBuffer()
-    scientific_notation(io, x)
-    return String(take!(io))
-end
-
 Base.signbit(x::Decimal) = x.s
 
 Base.zero(::Type{Decimal}) = Decimal(false, 0, 0)
@@ -53,3 +6,23 @@ Base.one(::Type{Decimal}) = Decimal(false, 1, 0)
 Base.iszero(x::Decimal) = iszero(x.c)
 Base.isfinite(x::Decimal) = true
 Base.isnan(x::Decimal) = false
+
+"""
+    normalize(x::Decimal)
+
+Return an equal number reduced to its simplest form with all trailing zeros in
+the coefficient removed.
+
+# Examples
+```jldoctest
+julia> normalize(dec"1.2000")
+1.2
+
+julia> normalize(dec"-10000")
+-1E+4
+```
+"""
+function normalize(x::Decimal)
+    c, e = cancelfactor(x.c, Val(10))
+    return fix(Decimal(x.s, c, x.q + e))
+end

src/round.jl

@@ -1,22 +1,42 @@
-# Rounding
-function Base.round(x::Decimal; digits::Int=0, normal::Bool=false)
-    shift = BigInt(digits) + x.q
-    if shift > BigInt(0) || shift < x.q
-        (normal) ? x : normalize(x, rounded=true)
-    else
-        c = Base.round(x.c / BigInt(10)^(-shift))
-        d = Decimal(x.s, BigInt(c), x.q - shift)
-        (normal) ? d : normalize(d, rounded=true)
+function _round(x::Decimal, r::RoundingMode=RoundNearest;
+        digits::Union{Integer,Nothing}=nothing,
+        sigdigits::Union{Integer,Nothing}=nothing)
+    if !isnothing(digits) && !isnothing(sigdigits)
+        throw(ArgumentError("`round` cannot use both `digits` and `sigdigits` arguments"))
     end
-end
 
-function Base.trunc(x::Decimal; digits::Int=0, normal::Bool=false)
-    shift = BigInt(digits) + x.q
-    if shift > BigInt(0) || shift < x.q
-        (normal) ? x : normalize(x, rounded=true)
-    else
-        c = Base.trunc(x.c / BigInt(10)^(-shift))
-        d = Decimal(x.s, BigInt(c), x.q - shift)
-        (normal) ? d : normalize(d, rounded=true)
+    if isnothing(digits) && isnothing(sigdigits)
+        # If neither `digits` nor `sigdigits` was specified, remove all decimal
+        # digits
+        digits = 0
+    elseif isnothing(digits)
+        # If only `sigdigits` was specified, remove all digits besides
+        # `sigdigits` most significant
+        digits = -(ndigits(x.c) + x.q - sigdigits)
     end
+
+    @assert !isnothing(digits)
+
+    # `-x.q` is the number of digits after the decimal place
+    if digits ≥ -x.q
+        return x
+    end
+
+    trun_len = -(x.q + digits)
+    c = div(x.c, BigTen ^ trun_len, r)
+    return Decimal(x.s, c, x.q + trun_len)
+end
+
+# Deal with method ambiguities
+function Base.round(x::Decimal, ::RoundingMode{:NearestTiesAway})
+    return _round(x, RoundNearestTiesAway, digits=0)
+end
+function Base.round(x::Decimal, ::RoundingMode{:FromZero})
+    return _round(x, RoundFromZero, digits=0)
+end
+
+function Base.round(x::Decimal, r::RoundingMode=RoundNearest;
+        digits::Union{Integer,Nothing}=nothing,
+        sigdigits::Union{Integer,Nothing}=nothing)
+    return _round(x, r, digits=digits, sigdigits=sigdigits)
 end

test/runtests.jl

@@ -19,7 +19,6 @@ include("test_context.jl")
 include("test_decimal.jl")
 include("test_equals.jl")
 include("test_hash.jl")
-include("test_norm.jl")
 include("test_parse.jl")
 include("test_round.jl")
 include("test_show.jl")

test/test_decimal.jl

@@ -46,3 +46,9 @@ end
     @test isfinite(Decimal(0, 1, 1))
     @test !isnan(Decimal(0, 1, 1))
 end
+
+@testset "Normalize" begin
+    x = normalize(dec"-15.11000")
+    @test (x.c % 10) ≠ 0
+    @test x == dec"-15.11"
+end