Merge branch 'more-functions-3' into fixed-promotion

Author: MilesCranmer

src/disambiguities.jl

@@ -12,11 +12,3 @@ Base.:*(l::AbstractDimensions, r::Number) = error("Please use an `UnionAbstractQ
 Base.:*(l::Number, r::AbstractDimensions) = error("Please use an `UnionAbstractQuantity` for multiplication. You used multiplication on types: $(typeof(l)) and $(typeof(r)).")
 Base.:/(l::AbstractDimensions, r::Number) = error("Please use an `UnionAbstractQuantity` for division. You used division on types: $(typeof(l)) and $(typeof(r)).")
 Base.:/(l::Number, r::AbstractDimensions) = error("Please use an `UnionAbstractQuantity` for division. You used division on types: $(typeof(l)) and $(typeof(r)).")
-
-if VERSION < v"1.7"
-    for I in (Base.MultiplicativeInverses.UnsignedMultiplicativeInverse, Base.MultiplicativeInverses.SignedMultiplicativeInverse)
-        @eval function Base.div(x::T, y::$I{T}, r::RoundingMode=RoundToZero) where {T<:AbstractGenericQuantity}
-            return new_quantity(typeof(x), div(ustrip(x), y, r), dimension(x))
-        end
-    end
-end

src/math.jl

@@ -20,7 +20,7 @@ for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES
         function Base.:/(l::$type, r::$base_type)
             new_quantity(typeof(l), ustrip(l) / r, dimension(l))
         end
-        function Base.div(x::$type, y::$base_type, r::RoundingMode=RoundToZero)
+        function Base.div(x::$type, y::Number, r::RoundingMode=RoundToZero)
             new_quantity(typeof(x), div(ustrip(x), y, r), dimension(x))
         end
 
@@ -30,7 +30,7 @@ for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES
         function Base.:/(l::$base_type, r::$type)
             new_quantity(typeof(r), l / ustrip(r), inv(dimension(r)))
         end
-        function Base.div(x::$base_type, y::$type, r::RoundingMode=RoundToZero)
+        function Base.div(x::Number, y::$type, r::RoundingMode=RoundToZero)
             new_quantity(typeof(y), div(x, ustrip(y), r), inv(dimension(y)))
         end
 
@@ -175,7 +175,7 @@ end
 ############################## Same dimension as input ##################################
 for f in (
     :float, :abs, :real, :imag, :conj, :adjoint, :unsigned,
-    :nextfloat, :prevfloat, :identity, :transpose,
+    :nextfloat, :prevfloat, :identity, :transpose, :significand
 )
     @eval function Base.$f(q::UnionAbstractQuantity)
         return new_quantity(typeof(q), $f(ustrip(q)), dimension(q))
@@ -206,7 +206,7 @@ end
 function Base.round(::Type{Ti}, q::UnionAbstractQuantity, r::RoundingMode=RoundNearest) where {Ti<:Integer}
     return new_quantity(typeof(q), round(Ti, ustrip(q), r), dimension(q))
 end
-for f in (:floor, :trunc, :ceil, :significand)
+for f in (:floor, :trunc, :ceil)
     @eval begin
         function Base.$f(q::UnionAbstractQuantity)
             return new_quantity(typeof(q), $f(ustrip(q)), dimension(q))

test/unittests.jl

@@ -9,6 +9,12 @@ using StaticArrays: SArray, MArray
 using LinearAlgebra: norm
 using Test
 
+function record_show(s, f=show)
+    io = IOBuffer()
+    f(io, s)
+    return String(take!(io))
+end
+
 @testset "Basic utilities" begin
 
     for Q in [Quantity, GenericQuantity], T in [DEFAULT_VALUE_TYPE, Float16, Float32, Float64], R in [DEFAULT_DIM_BASE_TYPE, Rational{Int16}, Rational{Int32}, SimpleRatio{Int}, SimpleRatio{SafeInt16}]
@@ -447,14 +453,8 @@ end
     # Conversion to Rational without specifying type
     @test convert(Rational, FixedRational{UInt8,6}(2)) === Rational{UInt8}(2)
 
-    # Showing rationals
-    function show_string(i)
-        io = IOBuffer()
-        show(io, i)
-        return String(take!(io))
-    end
-    @test show_string(FixedRational{Int,10}(2)) == "2"
-    @test show_string(FixedRational{Int,10}(11//10)) == "11//10"
+    @test record_show(FixedRational{Int,10}(2)) == "2"
+    @test record_show(FixedRational{Int,10}(11//10)) == "11//10"
 
     # Promotion rules
     @test promote_type(FixedRational{Int64,10},FixedRational{BigInt,10}) == FixedRational{BigInt,10}
@@ -1164,6 +1164,8 @@ end
                 for y in valid_inputs[end-3:end]
                     qy_dimensionless = Quantity(y, D)
                     qy_dimensions = Quantity(y, convert(D, dimension(u"m/s")))
+                    @eval @test $f($y, $qx_dimensionless) == $f($y, $x)
+                    @eval @test $f($qy_dimensionless, $x) == $f($y, $x)
                     @eval @test $f($qy_dimensionless, $qx_dimensionless) == $f($y, $x)
                     @eval @test $f($qy_dimensions, $qx_dimensions) == $f($y, $x)
                     @eval @test_throws DimensionError $f($qy_dimensions, $x)
@@ -1172,6 +1174,8 @@ end
             end
         end
     end
+    s = record_show(DimensionError(u"km/s"), showerror)
+    @test occursin("not dimensionless", s)
 end
 
 @testset "Assorted dimensionful functions" begin
@@ -1180,7 +1184,7 @@ end
         :nextfloat, :prevfloat, :identity, :transpose,
         :copysign, :flipsign, :mod, :modf,
         :floor, :trunc, :ceil, :significand,
-        :ldexp, :round
+        :ldexp, :round,
     )
     for Q in (Quantity, GenericQuantity), D in (Dimensions, SymbolicDimensions), f in functions
         T = f in (:abs, :real, :imag, :conj) ? ComplexF64 : Float64
@@ -1200,6 +1204,11 @@ end
                     qx_dimensions = Q(x, dim)
                     qy_dimensions = Q(y, dim)
                     @eval @test $f($qx_dimensions, $qy_dimensions) == $Q($f($x, $y), $dim)
+                    if f in (:copysign, :flipsign, :mod)
+                        # Also do test without dimensions
+                        @eval @test $f($x, $qy_dimensions) == $f($x, $y)
+                        @eval @test $f($qx_dimensions, $y) == $Q($f($x, $y), $dim)
+                    end
                 end
             end
         elseif f == :unsigned
@@ -1208,7 +1217,7 @@ end
                 qx_dimensions = Q(x, dim)
                 @eval @test $f($qx_dimensions) == $Q($f($x), $dim)
             end
-        elseif f == :round
+        elseif f in (:round, :floor, :trunc, :ceil)
             for x in 5rand(T, 3) .- 2.5
                 dim = convert(D, dimension(u"m/s"))
                 qx_dimensions = Q(x, dim)
@@ -1237,3 +1246,18 @@ end
         end
     end
 end
+
+@testset "Test div" begin
+    for Q in (Quantity, GenericQuantity)
+        x = Q{Int}(10, length=1)
+        y = Q{Int}(3, mass=-1)
+        @test div(x, y) == Q{Int}(3, length=1, mass=1)
+        @test div(x, 3) == Q{Int}(3, length=1)
+        @test div(10, y) == Q{Int}(3, mass=1)
+        if VERSION >= v"1.9"
+            @test div(x, y, RoundFromZero) == Q{Int}(4, length=1, mass=1)
+            @test div(x, 3, RoundFromZero) == Q{Int}(4, length=1)
+            @test div(10, y, RoundFromZero) == Q{Int}(4, mass=1)
+        end
+    end
+end