Get simple complex operations working for RealQuantity

Author: MilesCranmer

src/math.jl

@@ -50,6 +50,24 @@ for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES
     end
 end
 
+# Complex multiplication
+for (type, _, _) in ABSTRACT_QUANTITY_TYPES
+    @eval begin
+        function Base.:*(l::Complex, r::$type)
+            new_quantity(typeof(r), l * ustrip(r), dimension(r))
+        end
+        function Base.:*(l::$type, r::Complex)
+            new_quantity(typeof(l), ustrip(l) * r, dimension(l))
+        end
+        function Base.:/(l::Complex, r::$type)
+            new_quantity(typeof(r), l / ustrip(r), inv(dimension(r)))
+        end
+        function Base.:/(l::$type, r::Complex)
+            new_quantity(typeof(r), ustrip(l) / r, dimension(r))
+        end
+    end
+end
+
 Base.:*(l::AbstractDimensions, r::AbstractDimensions) = map_dimensions(+, l, r)
 Base.:/(l::AbstractDimensions, r::AbstractDimensions) = map_dimensions(-, l, r)
 
@@ -125,6 +143,10 @@ for (type, _, _) in ABSTRACT_QUANTITY_TYPES
         Base.:^(l::$type, r::Integer) = _pow_int(l, r)
         Base.:^(l::$type, r::Number) = _pow(l, r)
         Base.:^(l::$type, r::Rational) = _pow(l, r)
+        function Base.:^(l::$type, r::Complex)
+            iszero(dimension(l)) || throw(DimensionError(l))
+            return new_quantity(typeof(l), ustrip(l)^r, dimension(l))
+        end
     end
 end
 @inline Base.literal_pow(::typeof(^), l::AbstractDimensions, ::Val{p}) where {p} = map_dimensions(Base.Fix1(*, p), l)

src/types.jl

@@ -191,7 +191,11 @@ A constant tuple of the existing abstract quantity types,
 each as a tuple with (1) the abstract type,
 (2) the base type, and (3) the default exported concrete type.
 """
-const ABSTRACT_QUANTITY_TYPES = ((AbstractQuantity, Number, Quantity), (AbstractGenericQuantity, Any, GenericQuantity), (AbstractRealQuantity, Real, RealQuantity))
+const ABSTRACT_QUANTITY_TYPES = (
+    (AbstractQuantity, Number, Quantity),
+    (AbstractGenericQuantity, Any, GenericQuantity),
+    (AbstractRealQuantity, Real, RealQuantity)
+)
 
 """
     promote_quantity(::Type{<:UnionAbstractQuantity}, t::Type{<:Any})
@@ -202,7 +206,7 @@ If the current quantity type can already accommodate `t`, then the current type
 promote_quantity(::Type{<:Union{GenericQuantity,Quantity,RealQuantity}}, ::Type{<:Any}) = GenericQuantity
 promote_quantity(::Type{<:Union{Quantity,RealQuantity}}, ::Type{<:Number}) = Quantity
 promote_quantity(::Type{<:RealQuantity}, ::Type{<:Real}) = RealQuantity
-promote_quantity(T, _) = t
+promote_quantity(T, _) = T
 
 for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES
     @eval begin
@@ -222,8 +226,13 @@ end
 
 const DEFAULT_QUANTITY_TYPE = RealQuantity{DEFAULT_VALUE_TYPE, DEFAULT_DIM_TYPE}
 
-new_dimensions(::Type{D}, dims...) where {D<:AbstractDimensions} = constructorof(D)(dims...)
-new_quantity(::Type{Q}, l, r) where {Q<:UnionAbstractQuantity} = constructorof(Q)(l, r)
+@inline function new_dimensions(::Type{D}, dims...) where {D<:AbstractDimensions}
+    return constructorof(D)(dims...)
+end
+@inline function new_quantity(::Type{Q}, val, dims) where {Q<:UnionAbstractQuantity}
+    Qout = promote_quantity(Q, typeof(val))
+    return constructorof(Qout)(val, dims)
+end
 
 dim_type(::Type{Q}) where {T,D<:AbstractDimensions,Q<:UnionAbstractQuantity{T,D}} = D
 dim_type(::Type{<:UnionAbstractQuantity}) = DEFAULT_DIM_TYPE