Merge branch 'main' into more-functions-3

Author: MilesCranmer

Project.toml

@@ -1,7 +1,7 @@
 name = "DynamicQuantities"
 uuid = "06fc5a27-2a28-4c7c-a15d-362465fb6821"
 authors = ["MilesCranmer <[email protected]> and contributors"]
-version = "0.8.0"
+version = "0.8.2"
 
 [deps]
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"

ext/DynamicQuantitiesUnitfulExt.jl

@@ -28,6 +28,9 @@ Base.convert(::Type{Unitful.Quantity}, x::DynamicQuantities.Quantity) =
         validate_upreferred()
         cumulator = DynamicQuantities.ustrip(x)
         dims = DynamicQuantities.dimension(x)
+        if dims isa DynamicQuantities.SymbolicDimensions
+            throw(ArgumentError("Conversion of a `DynamicQuantities.Quantity` to a `Unitful.Quantity` is not defined with dimensions of type `SymbolicDimensions`. Instead, you can first use the `uexpand` function to convert the dimensions to their base SI form of type `Dimensions`, then convert this quantity to a `Unitful.Quantity`."))
+        end
         equiv = unitful_equivalences()
         for dim in keys(dims)
             value = dims[dim]

src/units.jl

@@ -68,7 +68,7 @@ end
     kg,
 )
 @doc(
-    "Time in seconds. Available variants: `fs`, `ps`, `ns`, `μs` (/`us`), `ms`, `min`, `h` (/`hr`), `day`, `yr`, `kyr`, `Myr`, `Gyr`.",
+    "Time in seconds. Available variants: `fs`, `ps`, `ns`, `μs` (/`us`), `ms`, `min` (/`minute`), `h` (/`hr`), `day` (/`d`), `wk`, `yr`, `kyr`, `Myr`, `Gyr`.",
     s,
 )
 @doc(
@@ -158,15 +158,21 @@ end
 # Common assorted units
 ## Time
 @register_unit min 60 * s
+@register_unit minute min
 @register_unit h 60 * min
 @register_unit hr h
 @register_unit day 24 * h
+@register_unit d day
+@register_unit wk 7 * day
 @register_unit yr 365.25 * day
 
 @add_prefixes min ()
+@add_prefixes minute ()
 @add_prefixes h ()
 @add_prefixes hr ()
 @add_prefixes day ()
+@add_prefixes d ()
+@add_prefixes wk ()
 @add_prefixes yr (k, M, G)
 
 ## Volume

src/utils.jl

@@ -42,6 +42,29 @@ end
 function Base.promote_rule(::Type{<:Quantity{T1,D1}}, ::Type{<:Quantity{T2,D2}}) where {T1,T2,D1,D2}
     return Quantity{promote_type(T1,T2),promote_type(D1,D2)}
 end
+
+# Define promotion rules for all basic numeric types, individually.
+# We don't want to define an opinionated promotion on <:Number,
+# or even <:AbstractFloat, as it could conflict with other
+# abstract number packages which may try to do the same thing.
+# (which would lead to ambiguities)
+const BASE_NUMERIC_TYPES = Union{
+    Bool, Int8, UInt8, Int16, UInt16, Int32, UInt32,
+    Int64, UInt64, Int128, UInt128, Float16, Float32,
+    Float64, BigFloat, BigInt, ComplexF16, ComplexF32,
+    ComplexF64, Complex{BigFloat}, Rational{Int8}, Rational{UInt8},
+    Rational{Int16}, Rational{UInt16}, Rational{Int32}, Rational{UInt32},
+    Rational{Int64}, Rational{UInt64}, Rational{Int128}, Rational{UInt128},
+    Rational{BigInt},
+}
+for (type, _, _) in ABSTRACT_QUANTITY_TYPES
+    @eval function Base.promote_rule(::Type{Q}, ::Type{T2}) where {T,D,Q<:$type{T,D},T2<:BASE_NUMERIC_TYPES}
+        return with_type_parameters(Q, promote_type(T, T2), D)
+    end
+    @eval function Base.convert(::Type{Q}, x::BASE_NUMERIC_TYPES) where {T,D,Q<:$type{T,D}}
+        return new_quantity(Q, convert(T, x), D())
+    end
+end
 function Base.promote_rule(::Type{<:AbstractQuantity}, ::Type{<:Number})
     return Number
 end

test/test_unitful.jl

@@ -38,3 +38,8 @@ x = 1.0u"scale"
 @test typeof(x) <: Unitful.Quantity{Float64, MyScaleUnit.𝐒}
 @test_throws ErrorException convert(DynamicQuantities.Quantity, x)
 # These are not supported because there is no SI equivalency
+
+# issue 79
+symbolic = DynamicQuantities.us"s"
+@test_throws ArgumentError convert(Unitful.Quantity, symbolic)
+@test convert(Unitful.Quantity, DynamicQuantities.uexpand(symbolic)) == 1.0 * Unitful.u"s"

test/unittests.jl

@@ -467,15 +467,30 @@ end
     q2 = Quantity(2, mass=1)
     @test typeof(promote(q1, q2)) == typeof((q1, q1))
 
-    x = [0.5, 0.5u"km/s"]
-    @test x isa Vector{Number}
-
-    x = [0.5, GenericQuantity(0.5u"km/s")]
-    @test x isa Vector{Any}
+    q = 0.5u"km/s"
+    x = [0.5, q]
+    @test x isa Vector{typeof(q)}
+    @test x[1] == convert(typeof(q), 0.5)
+
+    q = GenericQuantity(0.5u"km/s")
+    x = [0.5, q]
+    @test x isa Vector{typeof(q)}
+
+    # Promotion with custom numeric type:
+    @eval struct MyNumber <: Real
+        x::Float64
+    end
+    a = 0.5u"km/s"
+    b = MyNumber(0.5)
+    ar = [a, b]
+    @test ar isa Vector{Number}
+    @test a === ar[1]
+    @test b === ar[2]
+    @test promote_type(MyNumber, typeof(a)) == Number
 
     # Explicit conversion so coverage can see it:
     D = DEFAULT_DIM_TYPE
-    @test promote_type(Quantity{Float32,D}, Float64) == Number
+    @test promote_type(Quantity{Float32,D}, Float64) == Quantity{Float64,D}
     @test promote_type(Quantity{Float32,D}, Quantity{Float64,D}) == Quantity{Float64,D}
     @test promote_type(Quantity{Float32,D}, GenericQuantity{Float64,D}) == GenericQuantity{Float64,D}
     @test promote_type(GenericQuantity{Float32,D}, GenericQuantity{Float64,D}) == GenericQuantity{Float64,D}