Merge branch 'additional-utils' into abstract-types-2

Author: MilesCranmer

src/fixed_rational.jl

@@ -43,6 +43,8 @@ Base.convert(::Type{Rational{R}}, x::F) where {R,F<:FixedRational} = Rational{R}
 Base.convert(::Type{Rational}, x::F) where {F<:FixedRational} = Rational{eltype(F)}(x.num, denom(F))
 Base.convert(::Type{AF}, x::F) where {AF<:AbstractFloat,F<:FixedRational} = convert(AF, x.num) / convert(AF, denom(F))
 Base.round(::Type{T}, x::F) where {T,F<:FixedRational} = div(convert(T, x.num), convert(T, denom(F)), RoundNearest)
+Base.promote(x::Integer, y::F) where {F<:FixedRational} = (F(x), y)
+Base.promote(x::F, y::Integer) where {F<:FixedRational} = (x, F(y))
 Base.promote(x, y::F) where {F<:FixedRational} = promote(x, convert(Rational, y))
 Base.promote(x::F, y) where {F<:FixedRational} = promote(convert(Rational, x), y)
 Base.show(io::IO, x::F) where {F<:FixedRational} = show(io, convert(Rational, x))

src/math.jl

@@ -25,10 +25,13 @@ Base.:+(l, r::AbstractQuantity) = dimension(l) == dimension(r) ? new_quantity(ty
 Base.:-(l::AbstractQuantity, r) = l + (-r)
 Base.:-(l, r::AbstractQuantity) = l + (-r)
 
-_pow(l::AbstractDimensions{R}, r::R) where {R} = map_dimensions(Base.Fix1(*, r), l)
-_pow(l::AbstractQuantity{T,R}, r::R) where {T,R} = new_quantity(typeof(l), ustrip(l)^convert(T, r), _pow(dimension(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)
 Base.:^(l::AbstractDimensions{R}, r::Number) where {R} = _pow(l, tryrationalize(R, r))
-Base.:^(l::AbstractQuantity{T,R}, r::Number) where {T,R} = _pow(l, tryrationalize(R, r))
+Base.:^(l::AbstractQuantity{T,R}, r::Integer) where {T,R} = _pow(l, r)
+Base.:^(l::AbstractQuantity{T,R}, r::Number) where {T,R} = _pow_as_T(l, tryrationalize(R, r))
 
 Base.inv(d::AbstractDimensions) = map_dimensions(-, d)
 Base.inv(q::AbstractQuantity) = new_quantity(typeof(q), inv(ustrip(q)), inv(dimension(q)))

src/units.jl

@@ -15,7 +15,7 @@ end
 function _add_prefixes(base_unit::Symbol, prefixes)
     all_prefixes = (
         f=1e-15, p=1e-12, n=1e-9, μ=1e-6, u=1e-6, m=1e-3, c=1e-2, d=1e-1,
-        k=1e3, M=1e6, G=1e9, T=1e12, P=1e15
+        k=1e3, M=1e6, G=1e9
     )
     expr = Expr(:block)
     for (prefix, value) in zip(keys(all_prefixes), values(all_prefixes))
@@ -90,11 +90,6 @@ const bar = 100 * kPa
 
 @add_prefixes bar ()
 
-## Energy
-const eV = 1.602176634e-19 * J
-
-@add_prefixes eV (m, k, M, G, T)
-
 # Do not wish to define Gaussian units, as it changes
 # some formulas. Safer to force user to work exclusively in one unit system.
 
@@ -109,9 +104,13 @@ corresponding `Quantity` object. For example, `uparse("m/s")`
 would be parsed to `Quantity(1.0, length=1, time=-1)`.
 """
 function uparse(s::AbstractString)
-    return eval(Meta.parse(s))::Quantity{DEFAULT_VALUE_TYPE,DEFAULT_DIM_TYPE}
+    return as_quantity(eval(Meta.parse(s)))::Quantity{DEFAULT_VALUE_TYPE,DEFAULT_DIM_TYPE}
 end
 
+as_quantity(q::Quantity) = q
+as_quantity(x::Number) = Quantity(convert(DEFAULT_VALUE_TYPE, x), DEFAULT_DIM_TYPE)
+as_quantity(x) = error("Unexpected type evaluated: $(typeof(x))")
+
 """
     @u_str(s::AbstractString)
 

src/utils.jl

@@ -40,6 +40,11 @@ Base.iszero(q::AbstractQuantity) = iszero(ustrip(q))
 Base.getindex(d::AbstractDimensions, k::Symbol) = getfield(d, k)
 Base.:(==)(l::AbstractDimensions, r::AbstractDimensions) = all_dimensions(==, l, r)
 Base.:(==)(l::AbstractQuantity, r::AbstractQuantity) = ustrip(l) == ustrip(r) && dimension(l) == dimension(r)
+Base.:(==)(l, r::AbstractQuantity) = ustrip(l) == ustrip(r) && dimension(l) == dimension(r)
+Base.:(==)(l::AbstractQuantity, r) = ustrip(l) == ustrip(r) && dimension(l) == dimension(r)
+Base.isless(l::AbstractQuantity, r::AbstractQuantity) = dimension(l) == dimension(r) ? isless(ustrip(l), ustrip(r)) : throw(DimensionError(l, r))
+Base.isless(l::AbstractQuantity, r) = dimension(l) == dimension(r) ? isless(ustrip(l), r) : throw(DimensionError(l, r))
+Base.isless(l, r::AbstractQuantity) = dimension(l) == dimension(r) ? isless(l, ustrip(r)) : throw(DimensionError(l, r))
 Base.isapprox(l::AbstractQuantity, r::AbstractQuantity; kws...) = isapprox(ustrip(l), ustrip(r); kws...) && dimension(l) == dimension(r)
 Base.length(::AbstractDimensions) = 1
 Base.length(::AbstractQuantity) = 1
@@ -54,7 +59,7 @@ Base.one(::Type{Quantity{T}}) where {T} = one(Quantity{T,DEFAULT_DIM_TYPE})
 Base.one(::Type{Quantity}) = one(Quantity{DEFAULT_VALUE_TYPE})
 Base.one(::Type{Dimensions{R}}) where {R} = Dimensions{R}()
 Base.one(::Type{Dimensions}) = one(Dimensions{DEFAULT_DIM_TYPE})
-Base.one(q::Quantity) = one(typeof(q))
+Base.one(q::Quantity) = Quantity(one(ustrip(q)), one(dimension(q)))
 Base.one(d::Dimensions) = one(typeof(d))
 
 # Additive identities:

test/unittests.jl

@@ -200,6 +200,8 @@ end
     @test one(Dimensions()) == Dimensions()
     @test typeof(one(Quantity)) == Quantity{DEFAULT_VALUE_TYPE,DEFAULT_DIM_TYPE}
     @test ustrip(one(Quantity)) === one(DEFAULT_VALUE_TYPE)
+    @test typeof(one(Quantity(ones(32, 32)))) == Quantity{Matrix{Float64},DEFAULT_DIM_TYPE}
+    @test dimension(one(Quantity(ones(32, 32), length=1))) == Dimensions()
 
     x = Quantity(1, length=1)
 
@@ -218,6 +220,19 @@ end
     @test cbrt(z) == Quantity(cbrt(-52), length=1 // 3, mass=2 // 3)
 
     @test 1.0 * (Dimensions(length=3)^2) == Quantity(1.0, length=6)
+
+    x = 0.9u"km/s"
+    y = 0.3 * x
+    @test x > y
+    @test y < x
+
+    x = Quantity(1.0)
+
+    @test x == 1.0
+    @test x >= 1.0
+    @test x < 2.0
+
+    @test_throws DimensionError x < 1.0u"m"
 end
 
 @testset "Manual construction" begin
@@ -278,4 +293,15 @@ end
     z = u"yr"
     @test utime(z) == 1
     @test ustrip(z) ≈ 60 * 60 * 24 * 365.25
+
+    # Test type stability of extreme range of units
+    @test typeof(u"1") == Quantity{Float64,DEFAULT_DIM_TYPE}
+    @test typeof(u"1f0") == Quantity{Float64,DEFAULT_DIM_TYPE}
+    @test typeof(u"s"^2) == Quantity{Float64,DEFAULT_DIM_TYPE}
+    @test typeof(u"Ω") == Quantity{Float64,DEFAULT_DIM_TYPE}
+    @test typeof(u"Gyr") == Quantity{Float64,DEFAULT_DIM_TYPE}
+    @test typeof(u"fm") == Quantity{Float64,DEFAULT_DIM_TYPE}
+    @test typeof(u"fm"^2) == Quantity{Float64,DEFAULT_DIM_TYPE}
+
+    @test_throws LoadError eval(:(u":x"))
 end