Merge branch 'main' into unitful-integration

Author: j-fu

Project.toml

@@ -1,27 +1,27 @@
 name = "DynamicQuantities"
 uuid = "06fc5a27-2a28-4c7c-a15d-362465fb6821"
 authors = ["MilesCranmer <miles.cranmer@gmail.com> and contributors"]
-version = "0.1.0"
+version = "0.2.0"
 
 [deps]
-Ratios = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SaferIntegers = "88634af6-177f-5301-88b8-7819386cfa38"
 Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 
 
 
 [compat]
-Ratios = "0.4"
 Requires = "1"
-SaferIntegers = "3"
 Unitful = "1"
 julia = "1.6"
 
 [extras]
+Ratios = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
+SaferIntegers = "88634af6-177f-5301-88b8-7819386cfa38"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 
 [targets]
-test = ["Test", "SafeTestsets","Documenter"]
+test = ["Test", "Ratios", "SaferIntegers", "SafeTestsets", "Documenter"]
+

README.md

@@ -94,18 +94,16 @@ julia> x ^ 1.5
 
 Each of these values has the same type, thus obviating the need for type inference at runtime.
 
-Furthermore, we can do dimensional analysis automatically:
+Furthermore, we can do dimensional analysis by detecting `DimensionError`:
 
 ```julia
 julia> x + 3 * x
 1.2 𝐋 ¹ᐟ² 𝐌 ¹
 
 julia> x + y
-INVALID
+ERROR: DimensionError: 0.3 𝐋 ¹ᐟ² 𝐌 ¹ and 10.2 𝐌 ² 𝐓 ⁻² have different dimensions
 ```
 
-We can see the second one has `valid(quantity) == false`. This doesn't throw an error by default, as it allows for stable return values.
-
 The dimensions of a `Quantity` can be accessed either with `dimension(quantity)` for the entire `Dimensions` object:
 
 ```julia

benchmark/benchmarks.jl

@@ -34,7 +34,7 @@ end
 SUITE["with_quantity"] = let s = BenchmarkGroup()
     f5(x, y) = x / y
     s["/y"] = @benchmarkable $f5(x, y) setup = (x = default(); y = default()) evals = 1000
-    f6(x, y) = x^y
-    s["^y"] = @benchmarkable $f6(x, y) setup = (x = default(); y = default() / dimension(default())) evals = 1000
+    f6(x, y) = x + y
+    s["+y"] = @benchmarkable $f6(x, y) setup = (x = default(); y = x + rand() * x) evals = 1000
     s
 end

coverage.jl

@@ -1,14 +1,15 @@
 using Coverage
 # process '*.cov' files
 coverage = process_folder() # defaults to src/; alternatively, supply the folder name as argument
+push!(coverage, process_folder("ext/")...)
 
 LCOV.writefile("lcov.info", coverage)
 
 # process '*.info' files
 coverage = merge_coverage_counts(
     coverage,
     filter!(
-        let prefixes = (joinpath(pwd(), "src", ""),)
+        let prefixes = (joinpath(pwd(), "src", ""), joinpath(pwd(), "ext", ""))
             c -> any(p -> startswith(c.filename, p), prefixes)
         end,
         LCOV.readfolder("test"),

ext/DynamicQuantitiesUnitfulExt.jl

@@ -29,20 +29,22 @@ Base.convert(::Type{Unitful.Quantity}, x::DynamicQuantities.Quantity) =
         cumulator
     end
 
-Base.convert(::Type{DynamicQuantities.Quantity}, x::Unitful.Quantity) =
+Base.convert(::Type{DynamicQuantities.Quantity}, x::Unitful.Quantity{T}) where {T} = convert(DynamicQuantities.Quantity{T,DynamicQuantities.DEFAULT_DIM_TYPE}, x)
+Base.convert(::Type{DynamicQuantities.Quantity{T,R}}, x::Unitful.Quantity) where {T,R} =
     let
         value = Unitful.ustrip(Unitful.upreferred(x))
-        dimension = convert(DynamicQuantities.Dimensions, Unitful.dimension(x))
-        return DynamicQuantities.Quantity(value, dimension)
+        dimension = convert(DynamicQuantities.Dimensions{R}, Unitful.dimension(x))
+        return DynamicQuantities.Quantity(convert(T, value), dimension)
     end
 
-Base.convert(::Type{DynamicQuantities.Dimensions}, d::Unitful.Dimensions{D}) where {D} =
+Base.convert(::Type{DynamicQuantities.Dimensions}, d::Unitful.Dimensions) = convert(DynamicQuantities.Dimensions{DynamicQuantities.DEFAULT_DIM_TYPE}, d)
+Base.convert(::Type{DynamicQuantities.Dimensions{R}}, d::Unitful.Dimensions{D}) where {R,D} =
     let
-        cumulator = DynamicQuantities.Dimensions()
+        cumulator = DynamicQuantities.Dimensions{R}()
         for dim in D
             dim_symbol = _map_dim_name_to_dynamic_units(typeof(dim))
             dim_power = dim.power
-            cumulator *= DynamicQuantities.Dimensions(; dim_symbol => dim_power)
+            cumulator *= DynamicQuantities.Dimensions(R; dim_symbol => dim_power)
         end
         cumulator
     end

src/DynamicQuantities.jl

@@ -1,13 +1,13 @@
 module DynamicQuantities
 import Unitful
 
-export Quantity, Dimensions, ustrip, dimension, valid
+export Quantity, Dimensions, DimensionError, ustrip, dimension, valid
 export ulength, umass, utime, ucurrent, utemperature, uluminosity, uamount
 
 
 export @q_str,@dynquantities, unitful,dynquantity
 
-import Ratios: SimpleRatio
+
 
 include("types.jl")
 include("utils.jl")

src/math.jl

@@ -1,41 +1,35 @@
 Base.:*(l::Dimensions, r::Dimensions) = @map_dimensions(+, l, r)
-Base.:*(l::Quantity, r::Quantity) = Quantity(l.value * r.value, l.dimensions * r.dimensions, l.valid && r.valid)
-Base.:*(l::Quantity, r::Dimensions) = Quantity(l.value, l.dimensions * r, l.valid)
-Base.:*(l::Dimensions, r::Quantity) = Quantity(r.value, l * r.dimensions, r.valid)
-Base.:*(l::Quantity, r::Number) = Quantity(l.value * r, l.dimensions, l.valid)
-Base.:*(l::Number, r::Quantity) = Quantity(l * r.value, r.dimensions, r.valid)
-Base.:*(l::Dimensions, r::Number) = Quantity(r, l, true)
-Base.:*(l::Number, r::Dimensions) = Quantity(l, r, true)
+Base.:*(l::Quantity, r::Quantity) = Quantity(l.value * r.value, l.dimensions * r.dimensions)
+Base.:*(l::Quantity, r::Dimensions) = Quantity(l.value, l.dimensions * r)
+Base.:*(l::Dimensions, r::Quantity) = Quantity(r.value, l * r.dimensions)
+Base.:*(l::Quantity, r::Number) = Quantity(l.value * r, l.dimensions)
+Base.:*(l::Number, r::Quantity) = Quantity(l * r.value, r.dimensions)
+Base.:*(l::Dimensions, r::Number) = Quantity(r, l)
+Base.:*(l::Number, r::Dimensions) = Quantity(l, r)
 
 Base.:/(l::Dimensions, r::Dimensions) = @map_dimensions(-, l, r)
-Base.:/(l::Quantity, r::Quantity) = Quantity(l.value / r.value, l.dimensions / r.dimensions, l.valid && r.valid)
-Base.:/(l::Quantity, r::Dimensions) = Quantity(l.value, l.dimensions / r, l.valid)
-Base.:/(l::Dimensions, r::Quantity) = Quantity(inv(r.value), l / r.dimensions, r.valid)
-Base.:/(l::Quantity, r::Number) = Quantity(l.value / r, l.dimensions, l.valid)
+Base.:/(l::Quantity, r::Quantity) = Quantity(l.value / r.value, l.dimensions / r.dimensions)
+Base.:/(l::Quantity, r::Dimensions) = Quantity(l.value, l.dimensions / r)
+Base.:/(l::Dimensions, r::Quantity) = Quantity(inv(r.value), l / r.dimensions)
+Base.:/(l::Quantity, r::Number) = Quantity(l.value / r, l.dimensions)
 Base.:/(l::Number, r::Quantity) = l * inv(r)
-Base.:/(l::Dimensions, r::Number) = Quantity(inv(r), l, true)
-Base.:/(l::Number, r::Dimensions) = Quantity(l, inv(r), true)
+Base.:/(l::Dimensions, r::Number) = Quantity(inv(r), l)
+Base.:/(l::Number, r::Dimensions) = Quantity(l, inv(r))
 
-Base.:+(l::Quantity, r::Quantity) = Quantity(l.value + r.value, l.dimensions, l.valid && r.valid && l.dimensions == r.dimensions)
-Base.:-(l::Quantity, r::Quantity) = Quantity(l.value - r.value, l.dimensions, l.valid && r.valid && l.dimensions == r.dimensions)
+Base.:+(l::Quantity, r::Quantity) = dimension(l) == dimension(r) ? Quantity(l.value + r.value, l.dimensions) : throw(DimensionError(l, r))
+Base.:-(l::Quantity, r::Quantity) = dimension(l) == dimension(r) ? Quantity(l.value - r.value, l.dimensions) : throw(DimensionError(l, r))
 
-Base.:^(l::Quantity, r::Quantity) =
-    let rr = tryrationalize(R, r.value)
-        Quantity(l.value^rr, l.dimensions^rr, l.valid && r.valid && iszero(r.dimensions))
-    end
-Base.:^(l::Dimensions, r::R) = @map_dimensions(Base.Fix1(*, r), l)
-Base.:^(l::Dimensions, r::Number) = l^tryrationalize(R, r)
-Base.:^(l::Quantity, r::Number) =
-    let rr = tryrationalize(R, r)
-        Quantity(l.value^rr, l.dimensions^rr, l.valid)
-    end
+_pow(l::Dimensions{R}, r::R) where {R} = @map_dimensions(Base.Fix1(*, r), l)
+_pow(l::Quantity{T,R}, r::R) where {T,R} = Quantity(l.value^convert(T, r), _pow(l.dimensions, r))
+Base.:^(l::Dimensions{R}, r::Number) where {R} = _pow(l, tryrationalize(R, r))
+Base.:^(l::Quantity{T,R}, r::Number) where {T,R} = _pow(l, tryrationalize(R, r))
 
 Base.inv(d::Dimensions) = @map_dimensions(-, d)
-Base.inv(q::Quantity) = Quantity(inv(q.value), inv(q.dimensions), q.valid)
+Base.inv(q::Quantity) = Quantity(inv(q.value), inv(q.dimensions))
 
-Base.sqrt(d::Dimensions) = d^(1 // 2)
-Base.sqrt(q::Quantity) = Quantity(sqrt(q.value), sqrt(q.dimensions), q.valid)
-Base.cbrt(d::Dimensions) = d^(1 // 3)
-Base.cbrt(q::Quantity) = Quantity(cbrt(q.value), cbrt(q.dimensions), q.valid)
+Base.sqrt(d::Dimensions{R}) where {R} = d^inv(convert(R, 2))
+Base.sqrt(q::Quantity) = Quantity(sqrt(q.value), sqrt(q.dimensions))
+Base.cbrt(d::Dimensions{R}) where {R} = d^inv(convert(R, 3))
+Base.cbrt(q::Quantity) = Quantity(cbrt(q.value), cbrt(q.dimensions))
 
-Base.abs(q::Quantity) = Quantity(abs(q.value), q.dimensions, q.valid)
+Base.abs(q::Quantity) = Quantity(abs(q.value), q.dimensions)

src/types.jl

@@ -1,12 +1,5 @@
-import Ratios: SimpleRatio
-import SaferIntegers: SafeInt
-
-const INT_TYPE = SafeInt
-const R = SimpleRatio{INT_TYPE}
-const ZERO = R(0)
-const DIMENSION_NAMES = (:length, :mass, :time, :current, :temperature, :luminosity, :amount)
-const DIMENSION_SYNONYMS = (:𝐋, :𝐌, :𝐓, :𝐈, :𝚯, :𝐉, :𝐍)
-const SYNONYM_MAPPING = NamedTuple(DIMENSION_NAMES .=> DIMENSION_SYNONYMS)
+const DEFAULT_DIM_TYPE = Rational{Int16}
+const DEFAULT_VALUE_TYPE = Float64
 
 """
     Dimensions
@@ -17,15 +10,15 @@ example, the dimensions of velocity are `Dimensions(length=1, time=-1)`.
 
 # Fields
 
-- `length::Rational{Int}`: length dimension (i.e., meters^(length))
-- `mass::Rational{Int}`: mass dimension (i.e., kg^(mass))
-- `time::Rational{Int}`: time dimension (i.e., s^(time))
-- `current::Rational{Int}`: current dimension (i.e., A^(current))
-- `temperature::Rational{Int}`: temperature dimension (i.e., K^(temperature))
-- `luminosity::Rational{Int}`: luminosity dimension (i.e., cd^(luminosity))
-- `amount::Rational{Int}`: amount dimension (i.e., mol^(amount))
+- `length`: length dimension (i.e., meters^(length))
+- `mass`: mass dimension (i.e., kg^(mass))
+- `time`: time dimension (i.e., s^(time))
+- `current`: current dimension (i.e., A^(current))
+- `temperature`: temperature dimension (i.e., K^(temperature))
+- `luminosity`: luminosity dimension (i.e., cd^(luminosity))
+- `amount`: amount dimension (i.e., mol^(amount))
 """
-struct Dimensions
+struct Dimensions{R <: Real}
     length::R
     mass::R
     time::R
@@ -34,27 +27,40 @@ struct Dimensions
     luminosity::R
     amount::R
 
-    Dimensions(length::R, mass::R, time::R, current::R, temperature::R, luminosity::R, amount::R) =
-        new(length, mass, time, current, temperature, luminosity, amount)
-    Dimensions(; kws...) = Dimensions(
-        tryrationalize(R, get(kws, :length, ZERO)),
-        tryrationalize(R, get(kws, :mass, ZERO)),
-        tryrationalize(R, get(kws, :time, ZERO)),
-        tryrationalize(R, get(kws, :current, ZERO)),
-        tryrationalize(R, get(kws, :temperature, ZERO)),
-        tryrationalize(R, get(kws, :luminosity, ZERO)),
-        tryrationalize(R, get(kws, :amount, ZERO)),
+    function Dimensions(length::_R,
+                        mass::_R,
+                        time::_R,
+                        current::_R,
+                        temperature::_R,
+                        luminosity::_R,
+                        amount::_R) where {_R<:Real}
+        new{_R}(length, mass, time, current, temperature, luminosity, amount)
+    end
+    Dimensions(; kws...) = Dimensions(DEFAULT_DIM_TYPE; kws...)
+    Dimensions(::Type{_R}; kws...) where {_R} = Dimensions(
+        tryrationalize(_R, get(kws, :length,      zero(_R))),
+        tryrationalize(_R, get(kws, :mass,        zero(_R))),
+        tryrationalize(_R, get(kws, :time,        zero(_R))),
+        tryrationalize(_R, get(kws, :current,     zero(_R))),
+        tryrationalize(_R, get(kws, :temperature, zero(_R))),
+        tryrationalize(_R, get(kws, :luminosity,  zero(_R))),
+        tryrationalize(_R, get(kws, :amount,      zero(_R))),
     )
+    Dimensions{_R}(; kws...) where {_R} = Dimensions(_R; kws...)
+    Dimensions{_R}(args...) where {_R} = Dimensions(Base.Fix1(convert, _R).(args)...)
 end
 
+const DIMENSION_NAMES = Base.fieldnames(Dimensions)
+const DIMENSION_SYNONYMS = (:𝐋, :𝐌, :𝐓, :𝐈, :𝚯, :𝐉, :𝐍)
+const SYNONYM_MAPPING = NamedTuple(DIMENSION_NAMES .=> DIMENSION_SYNONYMS)
+
 """
     Quantity{T}
 
 Physical quantity with value `value` of type `T` and dimensions `dimensions`.
-The `valid` field is used to indicate whether the quantity is valid or not
-(e.g., due to dimensional error). For example, the velocity of an object
-with mass 1 kg and velocity 2 m/s is `Quantity(2, mass=1, length=1, time=-1)`.
-You should access these fields with `ustrip(q)`, `dimensions(q)`, and `valid(q)`.
+For example, the velocity of an object with mass 1 kg and velocity
+2 m/s is `Quantity(2, mass=1, length=1, time=-1)`.
+You should access these fields with `ustrip(q)`, and `dimensions(q)`.
 You can access specific dimensions with `ulength(q)`, `umass(q)`, `utime(q)`,
 `ucurrent(q)`, `utemperature(q)`, `uluminosity(q)`, and `uamount(q)`.
 
@@ -65,15 +71,17 @@ including `*`, `+`, `-`, `/`, `^`, `sqrt`, and `cbrt`.
 
 - `value::T`: value of the quantity of some type `T`
 - `dimensions::Dimensions`: dimensions of the quantity
-- `valid::Bool`: whether the quantity is valid or not
 """
-struct Quantity{T}
+struct Quantity{T, R}
     value::T
-    dimensions::Dimensions
-    valid::Bool
+    dimensions::Dimensions{R}
+
+    Quantity(x; kws...) = new{typeof(x), DEFAULT_DIM_TYPE}(x, Dimensions(; kws...))
+    Quantity(x, ::Type{_R}; kws...) where {_R}  = new{typeof(x), _R}(x, Dimensions(_R; kws...))
+    Quantity(x, d::Dimensions{_R}) where {_R}  = new{typeof(x), _R}(x, d)
+end
 
-    Quantity(x; kws...) = new{typeof(x)}(x, Dimensions(; kws...), true)
-    Quantity(x, valid::Bool; kws...) = new{typeof(x)}(x, Dimensions(; kws...), valid)
-    Quantity(x, d::Dimensions) = new{typeof(x)}(x, d, true)
-    Quantity(x, d::Dimensions, valid::Bool) = new{typeof(x)}(x, d, valid)
+struct DimensionError{Q1,Q2} <: Exception
+    q1::Q1
+    q2::Q2
 end