Remove ::Number restrictions on math

Author: MilesCranmer

src/math.jl

@@ -2,28 +2,28 @@ Base.:*(l::Dimensions, r::Dimensions) = @map_dimensions(+, l, r)
 Base.:*(l::Quantity, r::Quantity) = Quantity(l.value * r.value, l.dimensions * r.dimensions)
 Base.:*(l::Quantity, r::Dimensions) = Quantity(l.value, l.dimensions * r)
 Base.:*(l::Dimensions, r::Quantity) = Quantity(r.value, l * r.dimensions)
-Base.:*(l::Quantity, r::Number) = Quantity(l.value * r, l.dimensions)
-Base.:*(l::Number, r::Quantity) = Quantity(l * r.value, r.dimensions)
-Base.:*(l::Dimensions, r::Number) = Quantity(r, l)
-Base.:*(l::Number, r::Dimensions) = Quantity(l, r)
+Base.:*(l::Quantity, r) = Quantity(l.value * r, l.dimensions)
+Base.:*(l, r::Quantity) = Quantity(l * r.value, r.dimensions)
+Base.:*(l::Dimensions, r) = Quantity(r, l)
+Base.:*(l, r::Dimensions) = Quantity(l, r)
 
 Base.:/(l::Dimensions, r::Dimensions) = @map_dimensions(-, l, r)
 Base.:/(l::Quantity, r::Quantity) = Quantity(l.value / r.value, l.dimensions / r.dimensions)
 Base.:/(l::Quantity, r::Dimensions) = Quantity(l.value, l.dimensions / r)
 Base.:/(l::Dimensions, r::Quantity) = Quantity(inv(r.value), l / r.dimensions)
-Base.:/(l::Quantity, r::Number) = Quantity(l.value / r, l.dimensions)
-Base.:/(l::Number, r::Quantity) = l * inv(r)
-Base.:/(l::Dimensions, r::Number) = Quantity(inv(r), l)
-Base.:/(l::Number, r::Dimensions) = Quantity(l, inv(r))
+Base.:/(l::Quantity, r) = Quantity(l.value / r, l.dimensions)
+Base.:/(l, r::Quantity) = l * inv(r)
+Base.:/(l::Dimensions, r) = Quantity(inv(r), l)
+Base.:/(l, r::Dimensions) = Quantity(l, inv(r))
 
 Base.:+(l::Quantity, r::Quantity) = dimension(l) == dimension(r) ? Quantity(l.value + r.value, l.dimensions) : throw(DimensionError(l, r))
 Base.:-(l::Quantity) = Quantity(-l.value, l.dimensions)
 Base.:-(l::Quantity, r::Quantity) = l + (-r)
 
-Base.:+(l::Quantity, r::Number) = dimension(l) == dimension(r) ? Quantity(l.value + r, l.dimensions) : throw(DimensionError(l, r))
-Base.:+(l::Number, r::Quantity) = dimension(l) == dimension(r) ? Quantity(l + r.value, r.dimensions) : throw(DimensionError(l, r))
-Base.:-(l::Quantity, r::Number) = l + (-r)
-Base.:-(l::Number, r::Quantity) = l + (-r)
+Base.:+(l::Quantity, r) = dimension(l) == dimension(r) ? Quantity(l.value + r, l.dimensions) : throw(DimensionError(l, r))
+Base.:+(l, r::Quantity) = dimension(l) == dimension(r) ? Quantity(l + r.value, r.dimensions) : throw(DimensionError(l, r))
+Base.:-(l::Quantity, r) = l + (-r)
+Base.:-(l, r::Quantity) = l + (-r)
 
 _pow(l::Dimensions{R}, r::R) where {R} = @map_dimensions(Base.Fix1(*, r), l)
 _pow(l::Quantity{T,R}, r::R) where {T,R} = Quantity(l.value^convert(T, r), _pow(l.dimensions, r))

src/utils.jl

@@ -111,15 +111,17 @@ Base.convert(::Type{Dimensions{R}}, d::Dimensions) where {R} = Dimensions{R}(d)
 Remove the units from a quantity.
 """
 ustrip(q::Quantity) = q.value
-ustrip(q::Number) = q
+ustrip(::Dimensions) = error("Cannot remove units from a `Dimensions` object.")
+ustrip(q) = q
 
 """
     dimension(q::Quantity)
 
 Get the dimensions of a quantity, returning a `Dimensions` object.
 """
 dimension(q::Quantity) = q.dimensions
-dimension(::Number) = Dimensions()
+dimension(d::Dimensions) = d
+dimension(_) = Dimensions()
 
 """
     ulength(q::Quantity)

test/unittests.jl

@@ -129,7 +129,12 @@ end
 
 @testset "Fallbacks" begin
     @test ustrip(0.5) == 0.5
+    @test ustrip(ones(32)) == ones(32)
     @test dimension(0.5) == Dimensions()
+    @test dimension(ones(32)) == Dimensions()
+    @test dimension(Dimensions()) === Dimensions()
+
+    @test_throws ErrorException ustrip(Dimensions())
 end
 
 @testset "Arrays" begin
@@ -147,6 +152,14 @@ end
 
         uX = X .* Quantity(2, length=2.5, luminosity=0.5)
         @test sum(X) == 0.5 * ustrip(sum(uX))
+
+        x = Quantity(ones(T, 32))
+        @test ustrip(x + ones(T, 32))[32] == 2
+        @test typeof(x + ones(T, 32)) <: Quantity{Vector{T}}
+        @test typeof(x - ones(T, 32)) <: Quantity{Vector{T}}
+        @test typeof(ones(T, 32) * Dimensions(length=1)) <: Quantity{Vector{T}}
+        @test typeof(ones(T, 32) / Dimensions(length=1)) <: Quantity{Vector{T}}
+        @test ones(T, 32) / Dimensions(length=1) == Quantity(ones(T, 32), length=-1)
     end
 end