Merge pull request #17 from SymbolicML/dimension-errors

Throw `DimensionError` rather than using a `valid` field in `Quantity`

Author: MilesCranmer

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

src/DynamicQuantities.jl

@@ -1,6 +1,6 @@
 module DynamicQuantities
 
-export Quantity, Dimensions, ustrip, dimension, valid
+export Quantity, Dimensions, DimensionError, ustrip, dimension, valid
 export ulength, umass, utime, ucurrent, utemperature, uluminosity, uamount
 
 include("types.jl")

src/math.jl

@@ -1,35 +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))
 
 _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), l.valid)
+_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{R}) where {R} = d^inv(convert(R, 2))
-Base.sqrt(q::Quantity) = Quantity(sqrt(q.value), sqrt(q.dimensions), q.valid)
+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), q.valid)
+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

@@ -57,10 +57,9 @@ 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)`.
 
@@ -71,17 +70,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, R}
     value::T
     dimensions::Dimensions{R}
-    valid::Bool
 
-    Quantity(x; kws...) = new{typeof(x), DEFAULT_DIM_TYPE}(x, Dimensions(; kws...), true)
-    Quantity(x, valid::Bool; kws...) = new{typeof(x), DEFAULT_DIM_TYPE}(x, Dimensions(; kws...), valid)
-    Quantity(x, ::Type{_R}, valid::Bool; kws...) where {_R} = new{typeof(x), _R}(x, Dimensions(_R; kws...), valid)
-    Quantity(x, ::Type{_R}; kws...) where {_R}  = new{typeof(x), _R}(x, Dimensions(_R; kws...), true)
-    Quantity(x, d::Dimensions{_R}) where {_R}  = new{typeof(x), _R}(x, d, true)
-    Quantity(x, d::Dimensions{_R}, valid::Bool) where {_R}  = new{typeof(x), _R}(x, d, valid)
+    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
+
+struct DimensionError{Q1,Q2} <: Exception
+    q1::Q1
+    q2::Q2
 end

src/utils.jl

@@ -26,7 +26,6 @@ end
 Base.float(q::Quantity{T}) where {T<:AbstractFloat} = convert(T, q)
 Base.convert(::Type{T}, q::Quantity) where {T<:Real} =
     let
-        @assert q.valid "Quantity $(q) is invalid!"
         @assert iszero(q.dimensions) "Quantity $(q) has dimensions! Use `ustrip` instead."
         return convert(T, q.value)
     end
@@ -37,8 +36,8 @@ Base.iszero(d::Dimensions) = @all_dimensions(iszero, d)
 Base.iszero(q::Quantity) = iszero(q.value)
 Base.getindex(d::Dimensions, k::Symbol) = getfield(d, k)
 Base.:(==)(l::Dimensions, r::Dimensions) = @all_dimensions(==, l, r)
-Base.:(==)(l::Quantity, r::Quantity) = l.value == r.value && l.dimensions == r.dimensions && l.valid == r.valid
-Base.isapprox(l::Quantity, r::Quantity; kws...) = isapprox(l.value, r.value; kws...) && l.dimensions == r.dimensions && l.valid == r.valid
+Base.:(==)(l::Quantity, r::Quantity) = l.value == r.value && l.dimensions == r.dimensions
+Base.isapprox(l::Quantity, r::Quantity; kws...) = isapprox(l.value, r.value; kws...) && l.dimensions == r.dimensions
 Base.length(::Dimensions) = 1
 Base.length(::Quantity) = 1
 Base.iterate(d::Dimensions) = (d, nothing)
@@ -68,7 +67,7 @@ Base.show(io::IO, d::Dimensions) =
         s = replace(s, r"\s*$" => "")
         print(io, s)
     end
-Base.show(io::IO, q::Quantity) = q.valid ? print(io, q.value, " ", q.dimensions) : print(io, "INVALID")
+Base.show(io::IO, q::Quantity) = print(io, q.value, " ", q.dimensions)
 
 string_rational(x) = isinteger(x) ? string(round(Int, x)) : string(x)
 pretty_print_exponent(io::IO, x) = print(io, " ", to_superscript(string_rational(x)))
@@ -84,6 +83,8 @@ tryrationalize(::Type{R}, x::R) where {R} = x
 tryrationalize(::Type{R}, x::Union{Rational,Integer}) where {R} = convert(R, x)
 tryrationalize(::Type{R}, x) where {R} = isinteger(x) ? convert(R, round(Int, x)) : convert(R, rationalize(Int, x))
 
+Base.showerror(io::IO, e::DimensionError) = print(io, "DimensionError: ", e.q1, " and ", e.q2, " have different dimensions")
+
 """
     ustrip(q::Quantity)
 
@@ -100,14 +101,6 @@ Get the dimensions of a quantity, returning a `Dimensions` object.
 dimension(q::Quantity) = q.dimensions
 dimension(::Number) = Dimensions()
 
-"""
-    valid(q::Quantity)
-
-Check if a quantity is valid. If invalid, dimensional analysis
-during a previous calculation failed (such as adding mass and velocity).
-"""
-valid(q::Quantity) = q.valid
-
 """
     ulength(q::Quantity)
 

test/unittests.jl

@@ -13,7 +13,6 @@ using Test
         @test typeof(x).parameters[2] == R
         @test ulength(x) == R(1 // 1)
         @test umass(x) == R(5 // 2)
-        @test valid(x)
         @test ustrip(x) ≈ T(0.2)
         @test dimension(x) == Dimensions(R, length=1, mass=5 // 2)
         if R == DEFAULT_DIM_TYPE
@@ -28,30 +27,26 @@ using Test
         @test ulength(y) == R(2 // 1)
         @test umass(y) == (5 // 1)
         @test ustrip(y) ≈ T(0.04)
-        @test valid(y)
 
         y = x + x
 
         @test ulength(y) == R(1 // 1)
         @test umass(y) == R(5 // 2)
         @test ustrip(y) ≈ T(0.4)
-        @test valid(y)
 
-        y = x^2 + x
-
-        @test !valid(y)
         if R <: Rational
             @test string(x) == "0.2 𝐋 ¹ 𝐌 ⁵ᐟ²"
             @test string(inv(x)) == "5.0 𝐋 ⁻¹ 𝐌 ⁻⁵ᐟ²"
         end
-        @test string(y) == "INVALID"
+
+        @test_throws DimensionError x^2 + x
+
 
         y = inv(x)
 
         @test ulength(y) == R(-1 // 1)
         @test umass(y) == R(-5 // 2)
         @test ustrip(y) ≈ R(5)
-        @test valid(y)
 
         y = x - x
 
@@ -68,10 +63,6 @@ using Test
 
         @test y ≈ x
 
-        y = Quantity(T(2 // 10), R, false, length=1, mass=5 // 2)
-
-        @test !(y ≈ x)
-
         y = Quantity(T(2 // 10), R, length=1, mass=6 // 2)
 
         @test !(y ≈ x)