Back to Quantity as default

Author: MilesCranmer

src/arrays.jl

@@ -15,7 +15,7 @@ and so can be used in most places where a normal array would be used, including
 # Constructors
 
 - `QuantityArray(v::AbstractArray, d::AbstractDimensions)`: Create a `QuantityArray` with value `v` and dimensions `d`,
-  using `RealQuantity` if the eltype of `v` is real, `Quantity` if it is numeric, and `GenericQuantity` otherwise.
+  using `Quantity` if it is numeric, and `GenericQuantity` otherwise.
 - `QuantityArray(v::AbstractArray{<:Number}, q::AbstractQuantity)`: Create a `QuantityArray` with value `v` and dimensions inferred
    with `dimension(q)`. This is so that you can easily create an array with the units module, like so:
    ```julia
@@ -54,9 +54,11 @@ end
 
 QuantityArray(v::AbstractArray; kws...) = QuantityArray(v, DEFAULT_DIM_TYPE(; kws...))
 for (type, base_type, default_type) in ABSTRACT_QUANTITY_TYPES
-    @eval begin
-        QuantityArray(v::AbstractArray{<:$base_type}, q::$type) = QuantityArray(v .* ustrip(q), dimension(q), typeof(q))
-        QuantityArray(v::AbstractArray{<:$base_type}, d::AbstractDimensions) = QuantityArray(v, d, $default_type)
+    @eval QuantityArray(v::AbstractArray{<:$base_type}, q::$type) = QuantityArray(v .* ustrip(q), dimension(q), typeof(q))
+
+    # Only define defaults for Quantity and GenericQuantity. Other types, the user needs to declare explicitly.
+    if type in (AbstractQuantity, AbstractGenericQuantity)
+        @eval QuantityArray(v::AbstractArray{<:$base_type}, d::AbstractDimensions) = QuantityArray(v, d, $default_type)
     end
 end
 QuantityArray(v::QA) where {Q<:UnionAbstractQuantity,QA<:AbstractArray{Q}} =

src/constants.jl

@@ -1,7 +1,6 @@
 module Constants
 
 import ..DEFAULT_QUANTITY_TYPE
-import ..RealQuantity
 import ..Units as U
 import ..Units: _add_prefixes
 

src/symbolic_dimensions.jl

@@ -264,6 +264,8 @@ function map_dimensions(op::O, l::SymbolicDimensions{L}, r::SymbolicDimensions{R
     return SymbolicDimensions(I, V)
 end
 
+const DEFAULT_SYMBOLIC_QUANTITY_TYPE = with_type_parameters(DEFAULT_QUANTITY_TYPE, DEFAULT_VALUE_TYPE, SymbolicDimensions{DEFAULT_DIM_BASE_TYPE})
+
 """
     SymbolicUnitsParse
 
@@ -277,7 +279,8 @@ module SymbolicUnitsParse
     import ..SYMBOL_CONFLICTS
     import ..SymbolicDimensions
 
-    import ...RealQuantity
+    import ...constructorof
+    import ...DEFAULT_SYMBOLIC_QUANTITY_TYPE
     import ...DEFAULT_VALUE_TYPE
     import ...DEFAULT_DIM_BASE_TYPE
 
@@ -287,7 +290,8 @@ module SymbolicUnitsParse
         import ..SYMBOL_CONFLICTS
         import ..SymbolicDimensions
 
-        import ..RealQuantity
+        import ..constructorof
+        import ..DEFAULT_SYMBOLIC_QUANTITY_TYPE
         import ..DEFAULT_VALUE_TYPE
         import ..DEFAULT_DIM_BASE_TYPE
 
@@ -299,11 +303,11 @@ module SymbolicUnitsParse
             CONSTANT_SYMBOLS_EXIST[] || lock(CONSTANT_SYMBOLS_LOCK) do
                 CONSTANT_SYMBOLS_EXIST[] && return nothing
                 for unit in setdiff(CONSTANT_SYMBOLS, SYMBOL_CONFLICTS)
-                    @eval const $unit = RealQuantity(DEFAULT_VALUE_TYPE(1.0), SymbolicDimensions{DEFAULT_DIM_BASE_TYPE}; $(unit)=1)
+                    @eval const $unit = constructorof(DEFAULT_SYMBOLIC_QUANTITY_TYPE)(DEFAULT_VALUE_TYPE(1.0), SymbolicDimensions{DEFAULT_DIM_BASE_TYPE}; $(unit)=1)
                 end
                 # Evaluate conflicting symbols to non-symbolic form:
                 for unit in SYMBOL_CONFLICTS
-                    @eval const $unit = convert(RealQuantity{DEFAULT_VALUE_TYPE,SymbolicDimensions}, EagerConstants.$unit)
+                    @eval const $unit = convert(DEFAULT_SYMBOLIC_QUANTITY_TYPE, EagerConstants.$unit)
                 end
                 CONSTANT_SYMBOLS_EXIST[] = true
             end
@@ -318,7 +322,7 @@ module SymbolicUnitsParse
         UNIT_SYMBOLS_EXIST[] || lock(UNIT_SYMBOLS_LOCK) do
             UNIT_SYMBOLS_EXIST[] && return nothing
             for unit in UNIT_SYMBOLS
-                @eval const $unit = RealQuantity(DEFAULT_VALUE_TYPE(1.0), SymbolicDimensions{DEFAULT_DIM_BASE_TYPE}; $(unit)=1)
+                @eval const $unit = constructorof(DEFAULT_SYMBOLIC_QUANTITY_TYPE)(DEFAULT_VALUE_TYPE(1.0), SymbolicDimensions{DEFAULT_DIM_BASE_TYPE}; $(unit)=1)
             end
             UNIT_SYMBOLS_EXIST[] = true
         end
@@ -329,27 +333,27 @@ module SymbolicUnitsParse
         sym_uparse(raw_string::AbstractString)
 
     Parse a string containing an expression of units and return the
-    corresponding `RealQuantity` object with `Float64` value.
+    corresponding `Quantity` object with `Float64` value.
     However, that unlike the regular `u"..."` macro, this macro uses
     `SymbolicDimensions` for the dimension type, which means that all units and
     constants are stored symbolically and will not automatically expand to SI
     units. For example, `sym_uparse("km/s^2")` would be parsed to
-    `RealQuantity(1.0, SymbolicDimensions, km=1, s=-2)`.
+    `Quantity(1.0, SymbolicDimensions, km=1, s=-2)`.
 
     Note that inside this expression, you also have access to the `Constants`
     module. So, for example, `sym_uparse("Constants.c^2 * Hz^2")` would evaluate to
-    `RealQuantity(1.0, SymbolicDimensions, c=2, Hz=2)`. However, note that due to
+    `Quantity(1.0, SymbolicDimensions, c=2, Hz=2)`. However, note that due to
     namespace collisions, a few physical constants are automatically converted.
     """
     function sym_uparse(raw_string::AbstractString)
         _generate_unit_symbols()
         Constants._generate_unit_symbols()
         raw_result = eval(Meta.parse(raw_string))
-        return copy(as_quantity(raw_result))::RealQuantity{DEFAULT_VALUE_TYPE,SymbolicDimensions{DEFAULT_DIM_BASE_TYPE}}
+        return copy(as_quantity(raw_result))::DEFAULT_SYMBOLIC_QUANTITY_TYPE
     end
 
-    as_quantity(q::RealQuantity) = q
-    as_quantity(x::Number) = RealQuantity(convert(DEFAULT_VALUE_TYPE, x), SymbolicDimensions{DEFAULT_DIM_BASE_TYPE})
+    as_quantity(q::DEFAULT_SYMBOLIC_QUANTITY_TYPE) = q
+    as_quantity(x::Number) = convert(DEFAULT_SYMBOLIC_QUANTITY_TYPE, x)
     as_quantity(x) = error("Unexpected type evaluated: $(typeof(x))")
 end
 
@@ -359,15 +363,15 @@ import .SymbolicUnitsParse: sym_uparse
     us"[unit expression]"
 
 Parse a string containing an expression of units and return the
-corresponding `RealQuantity` object with `Float64` value. However,
+corresponding `Quantity` object with `Float64` value. However,
 unlike the regular `u"..."` macro, this macro uses `SymbolicDimensions`
 for the dimension type, which means that all units and constants
 are stored symbolically and will not automatically expand to SI units.
-For example, `us"km/s^2"` would be parsed to `RealQuantity(1.0, SymbolicDimensions, km=1, s=-2)`.
+For example, `us"km/s^2"` would be parsed to `Quantity(1.0, SymbolicDimensions, km=1, s=-2)`.
 
 Note that inside this expression, you also have access to the `Constants`
 module. So, for example, `us"Constants.c^2 * Hz^2"` would evaluate to
-`RealQuantity(1.0, SymbolicDimensions, c=2, Hz=2)`. However, note that due to
+`Quantity(1.0, SymbolicDimensions, c=2, Hz=2)`. However, note that due to
 namespace collisions, a few physical constants are automatically converted.
 """
 macro us_str(s)

src/types.jl

@@ -214,7 +214,7 @@ for (type, base_type, _) in ABSTRACT_QUANTITY_TYPES
     end
 end
 
-const DEFAULT_QUANTITY_TYPE = RealQuantity{DEFAULT_VALUE_TYPE, DEFAULT_DIM_TYPE}
+const DEFAULT_QUANTITY_TYPE = Quantity{DEFAULT_VALUE_TYPE, DEFAULT_DIM_TYPE}
 
 @inline function new_dimensions(::Type{D}, dims...) where {D<:AbstractDimensions}
     return constructorof(D)(dims...)

src/units.jl

@@ -3,7 +3,6 @@ module Units
 import ..DEFAULT_DIM_TYPE
 import ..DEFAULT_VALUE_TYPE
 import ..DEFAULT_QUANTITY_TYPE
-import ..RealQuantity
 
 @assert DEFAULT_VALUE_TYPE == Float64 "`units.jl` must be updated to support a different default value type."
 

src/uparse.jl

@@ -1,6 +1,7 @@
 module UnitsParse
 
-import ..RealQuantity
+import ..constructorof
+import ..DEFAULT_QUANTITY_TYPE
 import ..DEFAULT_DIM_TYPE
 import ..DEFAULT_VALUE_TYPE
 import ..Units: UNIT_SYMBOLS
@@ -24,28 +25,28 @@ end
     uparse(s::AbstractString)
 
 Parse a string containing an expression of units and return the
-corresponding `RealQuantity` object with `Float64` value. For example,
-`uparse("m/s")` would be parsed to `RealQuantity(1.0, length=1, time=-1)`.
+corresponding `Quantity` object with `Float64` value. For example,
+`uparse("m/s")` would be parsed to `Quantity(1.0, length=1, time=-1)`.
 
 Note that inside this expression, you also have access to the `Constants`
 module. So, for example, `uparse("Constants.c^2 * Hz^2")` would evaluate to
 the quantity corresponding to the speed of light multiplied by Hertz,
 squared.
 """
 function uparse(s::AbstractString)
-    return as_quantity(eval(Meta.parse(s)))::RealQuantity{DEFAULT_VALUE_TYPE,DEFAULT_DIM_TYPE}
+    return as_quantity(eval(Meta.parse(s)))::DEFAULT_QUANTITY_TYPE
 end
 
-as_quantity(q::RealQuantity) = q
-as_quantity(x::Number) = RealQuantity(convert(DEFAULT_VALUE_TYPE, x), DEFAULT_DIM_TYPE)
+as_quantity(q::DEFAULT_QUANTITY_TYPE) = q
+as_quantity(x::Number) = convert(DEFAULT_QUANTITY_TYPE,  x)
 as_quantity(x) = error("Unexpected type evaluated: $(typeof(x))")
 
 """
     u"[unit expression]"
 
 Parse a string containing an expression of units and return the
-corresponding `RealQuantity` object with `Float64` value. For example,
-`u"km/s^2"` would be parsed to `RealQuantity(1000.0, length=1, time=-2)`.
+corresponding `Quantity` object with `Float64` value. For example,
+`u"km/s^2"` would be parsed to `Quantity(1000.0, length=1, time=-2)`.
 
 Note that inside this expression, you also have access to the `Constants`
 module. So, for example, `u"Constants.c^2 * Hz^2"` would evaluate to

test/unittests.jl

@@ -499,7 +499,7 @@ end
     @eval struct MyNumber <: Real
         x::Float64
     end
-    a = 0.5u"km/s"
+    a = RealQuantity(0.5u"km/s")
     b = MyNumber(0.5)
     ar = [a, b]
     @test ar isa Vector{Real}
@@ -704,13 +704,13 @@ end
     @test_throws DimensionError uconvert(us"nm * J", 5e-9u"m")
 
     # Types:
-    @test typeof(uconvert(us"nm", 5e-9u"m")) <: RealQuantity{Float64,<:SymbolicDimensions}
+    @test typeof(uconvert(us"nm", 5e-9u"m")) <: constructorof(DEFAULT_QUANTITY_TYPE){Float64,<:SymbolicDimensions}
     @test typeof(uconvert(us"nm", GenericQuantity(5e-9u"m"))) <: GenericQuantity{Float64,<:SymbolicDimensions}
     @test uconvert(GenericQuantity(us"nm"), GenericQuantity(5e-9u"m")) ≈ 5us"nm"
     @test uconvert(GenericQuantity(us"nm"), GenericQuantity(5e-9u"m")) ≈ GenericQuantity(5us"nm")
 
     # We only want to convert the dimensions, and ignore the quantity type:
-    @test typeof(uconvert(GenericQuantity(us"nm"), 5e-9u"m")) <: RealQuantity{Float64,<:SymbolicDimensions}
+    @test typeof(uconvert(GenericQuantity(us"nm"), 5e-9u"m")) <: constructorof(DEFAULT_QUANTITY_TYPE){Float64,<:SymbolicDimensions}
 
     q = 1.5u"Constants.M_sun"
     qs = uconvert(us"Constants.M_sun", 5.0 * q)
@@ -803,7 +803,7 @@ end
     end
 
     @testset "Rational power law" begin
-        x = 1.0u"m"
+        x = RealQuantity(1.0u"m")
         y = x ^ (3//2)
         @test y == Quantity(1.0, length=3//2)
         @test typeof(y) == RealQuantity{Float64,DEFAULT_DIM_TYPE}
@@ -1201,8 +1201,8 @@ end
         qy = QuantityArray(y; length=1)
 
         @test typeof(convert(typeof(qx), qy)) == typeof(qx)
-        @test convert(typeof(qx), qy)[1] isa RealQuantity{Float64}
-        @test convert(typeof(qx), qy)[1] == convert(RealQuantity{Float64}, qy[1])
+        @test convert(typeof(qx), qy)[1] isa Quantity{Float64}
+        @test convert(typeof(qx), qy)[1] == convert(Quantity{Float64}, qy[1])
     end
 end