Feature request: dimension helper functions?

[icweaver]

Hi Miles, just following up on my evil master plan for JuliaAstro, would you be open to a PR adding some convenience is<dimension> functions?

I'm not sure if this has been discussed somewhere already, but we're basically looking for a convenient way to dispatch on dimensions, e.g.,

julia> using DynamicQuantities

julia> x = 3u"m"
3.0 m

julia> v = 3u"m/s"
3.0 m s⁻¹

julia> function do_stuff(q::UnionAbstractQuantity)
           if islength(q)
               # <do length stuff>
           elseif isspeed(q)
               # <do speed stuff>
           # ...
           else
           end
       end

I see that this could be done by factoring out some of the dimension display logic here, to something like:

julia> function islength(q::UnionAbstractQuantity)
           d = dimension(q)
           dd = filter(k -> !iszero(d[k]), keys(d))
           return dd == (:length,) && d.length == 1
       end
islength (generic function with 1 method)

julia> function isspeed(q::UnionAbstractQuantity)
           d = dimension(q)
           dd = filter(k -> !iszero(d[k]), keys(d))
           return dd == (:length, :time) && d.length == 1 && d.time == -1
       end
isspeed (generic function with 1 method)

julia> islength(3u"m")
true

julia> isspeed(3u"m/s")
true

Alternatively, would this make sense as a trait that could be dispatched on at the type level, or would this run counter to the dynamic runtime design here?

[MilesCranmer]

Thanks for the idea, can you say more about what the use case is and why existing tools won't cut it

[icweaver]

Hi Miles, I'm currently seeing it as an organizational convenience in our repos, for example for doing some spectral density bookkeeping for units.

Would the equivalent look something like this in DQ?

julia> using DynamicQuantities

julia> using DynamicQuantities.Constants: c as c0

julia> @register_unit erg 1e-7u"J"

julia> @register_unit Å 1e-10u"m"

julia> @register_unit Jy 1e-26u"W / m^2 / Hz"

julia> const SpectralFluxDensity = Dimensions(; length = -1, mass = 1, time = -3)
m⁻¹ kg s⁻³

julia> const SpectralEnergyDensity = Dimensions(; mass = 1, time = -2)
kg s⁻²

julia> function F_nu(F, λ_ref)
           return if dimension(F) == SpectralFluxDensity
               (F * λ_ref^2 / c0) |> us"Jy"
           elseif dimension(F) == SpectralEnergyDensity
               F |> us"Jy"
           else
               error("Invalid unit passed")
           end
       end
F_nu (generic function with 1 method)

julia> F_nu(5u"erg/s/cm^2/Å", 2_000u"Å")
6.671281903963041e11 Jy

julia> F_nu(5u"erg/s/cm^2/Hz", 2_000u"Å")
4.999999999999999e23 Jy

julia> using Chairmarks

julia> @b F_nu(5u"erg/s/cm^2/Å", 2_000u"Å")
25.222 ns

julia> @b F_nu(5u"erg/s/cm^2/Hz", 2_000u"Å")
25.460 ns

Not totally apples-to-apples, but I do like how this approach is competitive with the Unitful approach in SpectralFitting.jl:

julia> using Unitful, UnitfulAstro

julia> using PhysicalConstants.CODATA2022: c_0 as c0

julia> @derived_dimension SpectralFluxDensity Unitful.𝐌 / Unitful.𝐋 / Unitful.𝐓^3

julia> @derived_dimension SpectralEnergyDensity Unitful.𝐌 / Unitful.𝐓^2

julia> F_nu_unitful(Fλ::SpectralFluxDensity, λref) = uconvert(u"Jy", Fλ * λref^2 / c0)
F_nu_unitful (generic function with 1 method)

julia> F_nu_unitful(Fν::SpectralEnergyDensity, x) = uconvert(u"Jy", Fν)
F_nu_unitful (generic function with 2 methods)

julia> F_nu_unitful(5u"erg/s/cm^2/Å", 2_000u"Å")
6.671281903963043e11 Jy

julia> F_nu_unitful(5u"erg/s/cm^2/Hz", 2_000u"Å")
5.0000000000000006e23 Jy

julia> using Chairmarks

julia> @b F_nu_unitful(5u"erg/s/cm^2/Å", 2_000u"Å")
1.101 ns

julia> @b F_nu_unitful(5u"erg/s/cm^2/Hz", 3)
1.126 ns

Which of course gets even more competitive if we keep things in base SI instead of converting to symbolic units.

At any rate, I'm cc'ing @cgarling who has been thinking about this more, in case they have other use cases where dispatching on units would be helpful