Constraint uconvert

Author: MilesCranmer

README.md

@@ -90,7 +90,13 @@ julia> room_temp = 100kPa
 ```
 
 Note that `Units` is an exported submodule, so you can
-also access this as `Units.kPa`.
+also access this as `Units.kPa`. You may like to define
+
+```julia
+julia> const U = Units; const C = Constants;
+```
+
+so that you can simply write, say, `U.kPa` or `C.m_e`.
 
 This supports a wide range of SI base and derived units, with common
 prefixes.
@@ -243,20 +249,7 @@ julia> using DynamicQuantities.SymbolicConstants: h
 
 Note that `SymbolicUnits` and `SymbolicConstants` are exported,
 so you can simply access these as `SymbolicUnits.cm` and `SymbolicConstants.h`,
-respectively. I like to work with these like so:
-
-```julia
-julia> const u = DynamicQuantities.SymbolicUnits;
-
-julia> const C = DynamicQuantities.SymbolicConstants;
-```
-
-so that I can simply write things like:
-
-```julia
-julia> u.yr * C.c |> uexpand |> uconvert(u.km)
-```
-
+respectively.
 
 ### Arrays
 

src/symbolic_dimensions.jl

@@ -171,23 +171,55 @@ uexpand(q::QuantityArray) = uexpand.(q)
 Convert a quantity `q` with base SI units to the symbolic units of `qout`, for `q` and `qout` with compatible units.
 Mathematically, the result has value `q / uexpand(qout)` and units `dimension(qout)`. 
 """
-function uconvert(qout::UnionAbstractQuantity{<:Any, <:AbstractSymbolicDimensions}, q::UnionAbstractQuantity{<:Any, <:Dimensions})
+function uconvert(qout::UnionAbstractQuantity{<:Any, <:SymbolicDimensions}, q::UnionAbstractQuantity{<:Any, <:Dimensions})
     @assert isone(ustrip(qout)) "You passed a quantity with a non-unit value to uconvert."
     qout_expanded = uexpand(qout)
     dimension(q) == dimension(qout_expanded) || throw(DimensionError(q, qout_expanded))
     new_val = ustrip(q) / ustrip(qout_expanded)
     new_dim = dimension(qout)
     return new_quantity(typeof(q), new_val, new_dim)
 end
-function uconvert(qout::UnionAbstractQuantity{<:Any,<:AbstractSymbolicDimensions}, q::QuantityArray{<:Any,<:Any,<:Dimensions})
+function uconvert(qout::UnionAbstractQuantity{<:Any,<:SymbolicDimensions}, q::QuantityArray{<:Any,<:Any,<:Dimensions})
     @assert isone(ustrip(qout)) "You passed a quantity with a non-unit value to uconvert."
     qout_expanded = uexpand(qout)
     dimension(q) == dimension(qout_expanded) || throw(DimensionError(q, qout_expanded))
     new_array = ustrip(q) ./ ustrip(qout_expanded)
     new_dim = dimension(qout)
     return QuantityArray(new_array, new_dim, quantity_type(q))
 end
-# TODO: Method for converting SymbolicDimensions -> SymbolicDimensions
+
+# Ensure we always do operations with SymbolicDimensions:
+function uconvert(
+    qout::UnionAbstractQuantity{T,<:SymbolicDimensionsSingleton{R}},
+    q::Union{
+        <:UnionAbstractQuantity{<:Any,<:Dimensions},
+        <:QuantityArray{<:Any,<:Any,<:Dimensions},
+    },
+) where {T,R}
+    return uconvert(
+        convert(
+            with_type_parameters(
+                typeof(qout),
+                T,
+                with_type_parameters(SymbolicDimensions, R),
+            ),
+            qout,
+        ),
+        q,
+    )
+end
+
+# Allow user to convert SymbolicDimensions -> SymbolicDimensions
+function uconvert(
+    qout::UnionAbstractQuantity{<:Any,<:AbstractSymbolicDimensions{R}},
+    q::Union{
+        <:UnionAbstractQuantity{<:Any,<:AbstractSymbolicDimensions},
+        <:QuantityArray{<:Any,<:Any,<:AbstractSymbolicDimensions},
+    },
+) where {R}
+    return uconvert(qout, uexpand(q))
+end
+
 
 """
     uconvert(qout::UnionAbstractQuantity{<:Any, <:AbstractSymbolicDimensions})

test/unittests.jl

@@ -1753,6 +1753,16 @@ end
     @test map_dimensions(+, SymbolicDimensions(dimension(km)), dimension(m)).km == 1
     @test map_dimensions(+, SymbolicDimensions(dimension(km)), dimension(m)).m == 1
     @test map_dimensions(+, SymbolicDimensions(dimension(km)), dimension(m)).cm == 0
+
+    # Note that we avoid converting to SymbolicDimensionsSingleton for uconvert:
+    @test km |> uconvert(us"m") == 1000m
+    @test km |> uconvert(us"m") isa Quantity{T,SymbolicDimensions{R}} where {T,R}
+    @test [km, km] isa Vector{Quantity{T,SymbolicDimensionsSingleton{R}}} where {T,R}
+    @test [km^2, km] isa Vector{Quantity{T,SymbolicDimensions{R}}} where {T,R}
+
+    # Symbolic dimensions retain symbols:
+    @test QuantityArray([km, km]) |> uconvert(us"m") == [1000m, 1000m]
+    @test QuantityArray([km, km]) |> uconvert(us"m") != [km, km]
 end
 
 @testset "Test div" begin