Merge branch 'abstract-types-2' into constants

Author: MilesCranmer

.github/workflows/CI.yml

@@ -37,6 +37,7 @@ jobs:
         run: |
           julia --color=yes --project=. -e 'import Pkg; Pkg.add("Coverage")'
           julia --color=yes --threads=auto --check-bounds=yes --depwarn=yes --code-coverage=user --project=. -e 'import Pkg; Pkg.test(coverage=true)'
+          DQ_TEST_UPREFERRED=true julia --color=yes --threads=auto --check-bounds=yes --depwarn=yes --code-coverage=user --project=. -e 'import Pkg; Pkg.test(coverage=true)'
           julia --color=yes --project=. coverage.jl
       - name: "Coveralls"
         uses: coverallsapp/github-action@v2

ext/DynamicQuantitiesUnitfulExt.jl

@@ -10,19 +10,28 @@ else
     import ..Unitful: @u_str
 end
 
-# This lets the user override the preferred units:
-function unitful_equivalences()
-    si_units = (length=u"m", mass=u"kg", time=u"s", current=u"A", temperature=u"K", luminosity=u"cd", amount=u"mol")
+function get_si_units()
+    return (length=u"m", mass=u"kg", time=u"s", current=u"A", temperature=u"K", luminosity=u"cd", amount=u"mol")
+end
+
+function validate_upreferred()
+    si_units = get_si_units()
     for k in keys(si_units)
         if Unitful.upreferred(si_units[k]) !== si_units[k]
             error("Found custom `Unitful.preferunits`. This is not supported when interfacing Unitful and DynamicQuantities: you must leave the default `Unitful.upreferred`, which is the SI base units.")
         end
     end
+    return true
+end
+
+function unitful_equivalences()
+    si_units = get_si_units()
     return NamedTuple((k => si_units[k] for k in keys(si_units)))
 end
 
 Base.convert(::Type{Unitful.Quantity}, x::DynamicQuantities.Quantity) =
     let
+        validate_upreferred()
         cumulator = DynamicQuantities.ustrip(x)
         dims = DynamicQuantities.dimension(x)
         equiv = unitful_equivalences()
@@ -42,9 +51,10 @@ Base.convert(::Type{DynamicQuantities.Quantity{T,D}}, x::Unitful.Quantity) where
         return DynamicQuantities.Quantity(convert(T, value), dimension)
     end
 
-Base.convert(::Type{DynamicQuantities.Dimensions}, d::Unitful.Dimensions) = convert(DynamicQuantities.Dimensions{DynamicQuantities.DEFAULT_DIM_TYPE}, d)
+Base.convert(::Type{DynamicQuantities.Dimensions}, d::Unitful.Dimensions) = convert(DynamicQuantities.DEFAULT_DIM_TYPE, d)
 Base.convert(::Type{DynamicQuantities.Dimensions{R}}, d::Unitful.Dimensions{D}) where {R,D} =
     let
+        validate_upreferred()
         cumulator = DynamicQuantities.Dimensions{R}()
         for dim in D
             dim_symbol = _map_dim_name_to_dynamic_units(typeof(dim))

src/math.jl

@@ -25,13 +25,15 @@ Base.:+(l, r::AbstractQuantity) = iszero(dimension(r)) ? new_quantity(typeof(r),
 Base.:-(l::AbstractQuantity, r) = l + (-r)
 Base.:-(l, r::AbstractQuantity) = l + (-r)
 
-_pow(l::AbstractDimensions, r) = map_dimensions(Base.Fix1(*, r), l)
-_pow(l::AbstractQuantity{T}, r) where {T} = new_quantity(typeof(l), ustrip(l)^r, _pow(dimension(l), r))
-_pow_as_T(l::AbstractQuantity{T}, r) where {T} = new_quantity(typeof(l), ustrip(l)^convert(T, r), _pow(l.dimensions, r))
-Base.:^(l::AbstractDimensions{R}, r::Integer) where {R} = _pow(l, r)
+# We don't promote on the dimension types:
+_pow(l::AbstractDimensions{R}, r::R) where {R} = map_dimensions(Base.Fix1(*, r), l)
 Base.:^(l::AbstractDimensions{R}, r::Number) where {R} = _pow(l, tryrationalize(R, r))
-Base.:^(l::AbstractQuantity{T,D}, r::Integer) where {T,R,D<:AbstractDimensions{R}} = _pow(l, r)
-Base.:^(l::AbstractQuantity{T,D}, r::Number) where {T,R,D<:AbstractDimensions{R}} = _pow_as_T(l, tryrationalize(R, r))
+Base.:^(l::AbstractQuantity{T,D}, r::Integer) where {T,R,D<:AbstractDimensions{R}} = new_quantity(typeof(l), ustrip(l)^r, dimension(l)^r)
+Base.:^(l::AbstractQuantity{T,D}, r::Number) where {T,R,D<:AbstractDimensions{R}} =
+    let dim_pow = tryrationalize(R, r), val_pow = convert(T, dim_pow)
+        # Need to ensure we take the numerical power by the rationalized quantity:
+        return new_quantity(typeof(l), ustrip(l)^val_pow, dimension(l)^dim_pow)
+    end
 
 Base.inv(d::AbstractDimensions) = map_dimensions(-, d)
 Base.inv(q::AbstractQuantity) = new_quantity(typeof(q), inv(ustrip(q)), inv(dimension(q)))

src/utils.jl

@@ -84,7 +84,8 @@ Base.show(io::IO, d::AbstractDimensions) =
         s = replace(s, r"\s*$" => "")
         print(io, s)
     end
-Base.show(io::IO, q::AbstractQuantity) = print(io, ustrip(q), " ", dimension(q))
+Base.show(io::IO, q::AbstractQuantity{<:Real}) = print(io, ustrip(q), " ", dimension(q))
+Base.show(io::IO, q::AbstractQuantity) = print(io, "(", ustrip(q), ") ", dimension(q))
 
 function dimension_name(::AbstractDimensions, k::Symbol)
     default_dimensions = (length="m", mass="kg", time="s", current="A", temperature="K", luminosity="cd", amount="mol")

test/runtests.jl

@@ -5,10 +5,15 @@ import Ratios: SimpleRatio
     @eval Base.round(T, x::SimpleRatio) = round(T, x.num // x.den)
 end
 
-@safetestset "Unitful.jl integration tests" begin
-    include("test_unitful.jl")
-end
-
-@safetestset "Unit tests" begin
-    include("unittests.jl")
+if parse(Bool, get(ENV, "DQ_TEST_UPREFERRED", "false"))
+    @safetestset "Test upreferred disallowed" begin
+        include("test_ban_upreferred.jl")
+    end
+else
+    @safetestset "Unitful.jl integration tests" begin
+        include("test_unitful.jl")
+    end
+    @safetestset "Unit tests" begin
+        include("unittests.jl")
+    end
 end

test/test_ban_upreferred.jl

@@ -0,0 +1,13 @@
+### These are tests we need to run with a fresh Julia runtime
+
+import Unitful
+import Unitful: @u_str
+Unitful.preferunits(u"km")
+using Test
+import DynamicQuantities
+
+x_unitful = 1.5u"km"
+x_dq = DynamicQuantities.Quantity(1500.0, length=1)
+
+@test_throws ErrorException convert(DynamicQuantities.Quantity, x_unitful)
+@test_throws ErrorException convert(Unitful.Quantity, x_dq)

test/test_unitful.jl

@@ -22,4 +22,19 @@ for T in [DEFAULT_VALUE_TYPE, Float16, Float32, Float64], R in [DEFAULT_DIM_BASE
 
     @test isapprox(convert(DynamicQuantities.Quantity{T,D}, x_unitful), x; atol=1e-6)
     @test risapprox(convert(Unitful.Quantity, convert(DynamicQuantities.Quantity{T,D}, x_unitful)), Unitful.upreferred(x_unitful); atol=1e-6)
+
+    @test typeof(convert(DynamicQuantities.Dimensions, Unitful.dimension(x_unitful))) == DynamicQuantities.Dimensions{DEFAULT_DIM_BASE_TYPE}
+end
+
+module MyScaleUnit
+    using Unitful
+    @dimension(𝐒, "𝐒", Scale)
+    @refunit(scale, "scale", Scale, 𝐒, false)
 end
+
+Unitful.register(MyScaleUnit)
+
+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

test/unittests.jl

@@ -129,6 +129,15 @@ using Test
     @test abs(x) == abs(Quantity(1.2, length=2 // 5))
 end
 
+@testset "Complex numbers" begin
+    x = (0.5 + 0.5im) * u"km/s"
+    @test string(x) == "(500.0 + 500.0im) m s⁻¹"
+    @test typeof(x) == Quantity{Complex{Float64}, DEFAULT_DIM_TYPE}
+    @test typeof(x^2) == Quantity{Complex{Float64}, DEFAULT_DIM_TYPE}
+    @test x^2/u"km/s"^2 == Quantity(0.5im)
+    @test x^2.5 ≈ (-5.088059320440205e6 + 1.2283661817565577e7im) * u"m^(5/2) * s^(-5/2)"
+end
+
 @testset "Fallbacks" begin
     @test ustrip(0.5) == 0.5
     @test ustrip(ones(32)) == ones(32)
@@ -272,6 +281,13 @@ end
     @test typeof(convert(Quantity{Float16}, q)) == Quantity{Float16,Dimensions{Rational{Int16}}}
     @test convert(Quantity, q) === q
 
+    # Test that regular type promotion applies:
+    q = Quantity(2, d)
+    @test typeof(q) == Quantity{Int64,typeof(d)}
+    @test typeof(q ^ 2) == Quantity{Int64,typeof(d)}
+    @test typeof(0.5 * q) == Quantity{Float64,typeof(d)}
+    @test typeof(inv(q)) == Quantity{Float64,typeof(d)}
+
     # Automatic conversions via constructor:
     for T in [Float16, Float32, Float64, BigFloat], R in [DEFAULT_DIM_BASE_TYPE, Rational{Int16}, Rational{Int32}, SimpleRatio{Int}, SimpleRatio{SafeInt16}]
         D = Dimensions{R}