Fix promotion scheme by not promoting value type itself

Author: MilesCranmer

src/math.jl

@@ -1,15 +1,15 @@
 for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES
     @eval begin
         function Base.:*(l::$type, r::$type)
-            l, r = promote(l, r)
+            l, r = promote_except_value(l, r)
             new_quantity(typeof(l), ustrip(l) * ustrip(r), dimension(l) * dimension(r))
         end
         function Base.:/(l::$type, r::$type)
-            l, r = promote(l, r)
+            l, r = promote_except_value(l, r)
             new_quantity(typeof(l), ustrip(l) / ustrip(r), dimension(l) / dimension(r))
         end
         function Base.div(x::$type, y::$type, r::RoundingMode=RoundToZero)
-            x, y = promote(x, y)
+            x, y = promote_except_value(x, y)
             new_quantity(typeof(x), div(ustrip(x), ustrip(y), r), dimension(x) / dimension(y))
         end
 
@@ -57,7 +57,7 @@ Base.:/(l::AbstractDimensions, r::AbstractDimensions) = map_dimensions(-, l, r)
 for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES, op in (:+, :-)
     @eval begin
         function Base.$op(l::$type, r::$type)
-            l, r = promote(l, r)
+            l, r = promote_except_value(l, r)
             dimension(l) == dimension(r) || throw(DimensionError(l, r))
             return new_quantity(typeof(l), $op(ustrip(l), ustrip(r)), dimension(l))
         end
@@ -81,7 +81,7 @@ for op in (:*, :/, :+, :-, :div, :atan, :atand, :copysign, :flipsign, :mod),
 
     t1 == t2 && continue
 
-    @eval Base.$op(l::$t1, r::$t2) = $op(promote(l, r)...)
+    @eval Base.$op(l::$t1, r::$t2) = $op(promote_except_value(l, r)...)
 end
 
 # We don't promote on the dimension types:
@@ -156,7 +156,7 @@ for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES, f in (:atan, :atand)
             return $f(ustrip(x))
         end
         function Base.$f(y::$type, x::$type)
-            y, x = promote(y, x)
+            y, x = promote_except_value(y, x)
             dimension(y) == dimension(x) || throw(DimensionError(y, x))
             return $f(ustrip(y), ustrip(x))
         end
@@ -186,7 +186,7 @@ for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES, f in (:copysign, :flipsign,
     # and ignore any dimensions on y, since those will cancel out.
     @eval begin
         function Base.$f(x::$type, y::$type)
-            x, y = promote(x, y)
+            x, y = promote_except_value(x, y)
             return new_quantity(typeof(x), $f(ustrip(x), ustrip(y)), dimension(x))
         end
         function Base.$f(x::$type, y::$base_type)

src/utils.jl

@@ -46,6 +46,25 @@ function Base.promote_rule(::Type{<:AbstractQuantity}, ::Type{<:Number})
     return Number
 end
 
+"""
+    promote_except_value(q1::UnionAbstractQuantity, q2::UnionAbstractQuantity)
+
+This applies a promotion to the quantity type, and the dimension type,
+but *not* the value type. This is necessary because sometimes we would
+want to multiply a quantity array with a scalar quantity, and wish to use
+promotion on the quantity type itself, but don't want to promote to a
+single value type.
+"""
+@inline function promote_except_value(q1::Q1, q2::Q2) where {T1,D1,T2,D2,Q1<:UnionAbstractQuantity{T1,D1},Q2<:UnionAbstractQuantity{T2,D2}}
+    Q = promote_type(Q1, Q2)
+    D = promote_type(D1, D2)
+
+    Q1_out = with_type_parameters(Q, T1, D)
+    Q2_out = with_type_parameters(Q, T2, D)
+    return convert(Q1_out, q1), convert(Q2_out, q2)
+end
+@inline promote_except_value(q1::Q, q2::Q) where {Q<:UnionAbstractQuantity} = (q1, q2)
+
 Base.keys(d::AbstractDimensions) = dimension_names(typeof(d))
 Base.getindex(d::AbstractDimensions, k::Symbol) = getfield(d, k)
 
@@ -77,7 +96,7 @@ Base.keys(q::UnionAbstractQuantity) = keys(ustrip(q))
 
 # Numeric checks
 function Base.isapprox(l::UnionAbstractQuantity, r::UnionAbstractQuantity; kws...)
-    l, r = promote(l, r)
+    l, r = promote_except_value(l, r)
     return isapprox(ustrip(l), ustrip(r); kws...) && dimension(l) == dimension(r)
 end
 function Base.isapprox(l::Number, r::UnionAbstractQuantity; kws...)
@@ -90,14 +109,14 @@ function Base.isapprox(l::UnionAbstractQuantity, r::Number; kws...)
 end
 Base.iszero(d::AbstractDimensions) = all_dimensions(iszero, d)
 function Base.:(==)(l::UnionAbstractQuantity, r::UnionAbstractQuantity)
-    l, r = promote(l, r)
+    l, r = promote_except_value(l, r)
     ustrip(l) == ustrip(r) && dimension(l) == dimension(r)
 end
 Base.:(==)(l::Number, r::UnionAbstractQuantity) = ustrip(l) == ustrip(r) && iszero(dimension(r))
 Base.:(==)(l::UnionAbstractQuantity, r::Number) = ustrip(l) == ustrip(r) && iszero(dimension(l))
 Base.:(==)(l::AbstractDimensions, r::AbstractDimensions) = all_dimensions(==, l, r)
 function Base.isless(l::UnionAbstractQuantity, r::UnionAbstractQuantity)
-    l, r = promote(l, r)
+    l, r = promote_except_value(l, r)
     dimension(l) == dimension(r) || throw(DimensionError(l, r))
     return isless(ustrip(l), ustrip(r))
 end

test/unittests.jl

@@ -676,7 +676,7 @@ end
         q = convert(Q{Float16}, 1.5u"g")
         qs = uconvert(convert(Q{Float16}, us"g"), 5 * q)
         @test typeof(qs) <: Q{Float16,<:SymbolicDimensions{<:Any}}
-        @test qs ≈ 7.5us"g"
+        @test isapprox(qs, 7.5us"g"; atol=0.01)
 
         # Arrays
         x = [1.0, 2.0, 3.0] .* Q(u"kg")