Change scaledual to match original intent. Fixes #130. (#132)

Author: timholy

src/FixedPointNumbers.jl

@@ -188,14 +188,21 @@ for f in (:rem, :mod, :mod1, :min, :max)
     end
 end
 
-# When multiplying by a float, reduce two multiplies to one.
-# Particularly useful for arrays.
-scaledual(Tdual::Type, x) = oneunit(Tdual), x
-scaledual(b::Tdual, x) where {Tdual <: Number} = b, x
-scaledual(Tdual::Type, x::Union{T,AbstractArray{T}}) where {T <: FixedPoint} =
-    convert(Tdual, 1/oneunit(T)), reinterpret(rawtype(T), x)
-scaledual(b::Tdual, x::Union{T,AbstractArray{T}}) where {Tdual <: Number,T <: FixedPoint} =
-    convert(Tdual, b/oneunit(T)), reinterpret(rawtype(T), x)
+"""
+    sd, ad = scaledual(s::Number, a)
+
+Return `sd` and `ad` such that `sd * ad == s * a`.
+When `a` is an array of FixedPoint numbers, `sd*ad` might be faster to compute than `s*a`.
+"""
+scaledual(b::Number, x::Union{Number,AbstractArray{<:Number}}) = b, x
+scaledual(b::Number, x::FixedPoint) = b/rawone(x), reinterpret(x)
+scaledual(b::Number, x::AbstractArray{T}) where T <: FixedPoint =
+    b/rawone(T), reinterpret(rawtype(T), x)
+
+scaledual(::Type{Tdual}, x::Union{Number,AbstractArray{<:Number}}) where Tdual = oneunit(Tdual), x
+scaledual(::Type{Tdual}, x::FixedPoint) where Tdual = convert(Tdual, 1/rawone(x)), reinterpret(x)
+scaledual(::Type{Tdual}, x::AbstractArray{T}) where {Tdual, T <: FixedPoint} =
+    convert(Tdual, 1/rawone(T)), reinterpret(rawtype(T), x)
 
 @noinline function throw_converterror(::Type{T}, x) where {T <: FixedPoint}
     n = 2^(8*sizeof(T))

test/normed.jl

@@ -274,32 +274,30 @@ end
     @test eval(Meta.parse(str)) == x
 end
 
-# scaledual
-function generic_scale!(C::AbstractArray, X::AbstractArray, s::Number)
-    length(C) == length(X) || error("C must be the same length as X")
-    for i = 1:length(X)
-        @inbounds C[i] = X[i]*s
-    end
-    C
-end
-
 @testset "scaledual" begin
     a = rand(UInt8, 10)
-    rfloat = similar(a, Float32)
-    rfixed = similar(rfloat)
     af8 = reinterpret(N0f8, a)
-
     b = 0.5
+
     bd, eld = scaledual(b, af8[1])
-    @assert b*a[1] == bd*eld
-
-    b, ad = scaledual(0.5, a)
-    @test b == 0.5
-    @test ad == a
-    b, ad = scaledual(0.5, ad)
-    generic_scale!(rfloat, a, 0.5)
-    generic_scale!(rfixed, ad, b)
-    @test rfloat == rfixed
+    @test b*af8[1] == bd*eld
+    bd, ad = scaledual(b, af8)
+    @test b*af8 == bd*ad
+
+    bd, eld = scaledual(b, a[1])
+    @test b*a[1] == bd*eld
+    bd, ad = scaledual(b, a)
+    @test b*a == bd*ad
+
+    bd, eld = scaledual(Float64, af8[1])
+    @test 1.0*af8[1] == bd*eld
+    bd, ad = scaledual(Float64, af8)
+    @test 1.0*af8 == bd*ad
+
+    bd, eld = scaledual(Float64, a[1])
+    @test 1.0*a[1] == bd*eld
+    bd, ad = scaledual(Float64, a)
+    @test 1.0*a == bd*ad    
 end
 
 @testset "reductions" begin