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

Author: MilesCranmer

ext/DynamicQuantitiesUnitfulExt.jl

@@ -35,10 +35,10 @@ Base.convert(::Type{Unitful.Quantity}, x::DynamicQuantities.Quantity) =
     end
 
 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} =
+Base.convert(::Type{DynamicQuantities.Quantity{T,D}}, x::Unitful.Quantity) where {T,R,D<:DynamicQuantities.AbstractDimensions{R}} =
     let
         value = Unitful.ustrip(Unitful.upreferred(x))
-        dimension = convert(DynamicQuantities.Dimensions{R}, Unitful.dimension(x))
+        dimension = convert(D, Unitful.dimension(x))
         return DynamicQuantities.Quantity(convert(T, value), dimension)
     end
 

src/math.jl

@@ -4,17 +4,17 @@ Base.:*(l::AbstractQuantity, r::AbstractDimensions) = new_quantity(typeof(l), us
 Base.:*(l::AbstractDimensions, r::AbstractQuantity) = new_quantity(typeof(r), ustrip(r), l * dimension(r))
 Base.:*(l::AbstractQuantity, r) = new_quantity(typeof(l), ustrip(l) * r, dimension(l))
 Base.:*(l, r::AbstractQuantity) = new_quantity(typeof(r), l * ustrip(r), dimension(r))
-Base.:*(l::AbstractDimensions, r) = new_quantity(typeof(l), r, l)
-Base.:*(l, r::AbstractDimensions) = new_quantity(typeof(r), l, r)
+Base.:*(l::AbstractDimensions, r) = error("Please use an `AbstractQuantity` for multiplication. You used multiplication on types: $(typeof(l)) and $(typeof(r)).")
+Base.:*(l, r::AbstractDimensions) = error("Please use an `AbstractQuantity` for multiplication. You used multiplication on types: $(typeof(l)) and $(typeof(r)).")
 
 Base.:/(l::AbstractDimensions, r::AbstractDimensions) = map_dimensions(-, l, r)
 Base.:/(l::AbstractQuantity, r::AbstractQuantity) = new_quantity(typeof(l), ustrip(l) / ustrip(r), dimension(l) / dimension(r))
 Base.:/(l::AbstractQuantity, r::AbstractDimensions) = new_quantity(typeof(l), ustrip(l), dimension(l) / r)
 Base.:/(l::AbstractDimensions, r::AbstractQuantity) = new_quantity(typeof(r), inv(ustrip(r)), l / dimension(r))
 Base.:/(l::AbstractQuantity, r) = new_quantity(typeof(l), ustrip(l) / r, dimension(l))
 Base.:/(l, r::AbstractQuantity) = l * inv(r)
-Base.:/(l::AbstractDimensions, r) = new_quantity(typeof(l), inv(r), l)
-Base.:/(l, r::AbstractDimensions) = new_quantity(typeof(r), l, inv(r))
+Base.:/(l::AbstractDimensions, r) = error("Please use an `AbstractQuantity` for division. You used division on types: $(typeof(l)) and $(typeof(r)).")
+Base.:/(l, r::AbstractDimensions) = error("Please use an `AbstractQuantity` for division. You used division on types: $(typeof(l)) and $(typeof(r)).")
 
 Base.:+(l::AbstractQuantity, r::AbstractQuantity) = dimension(l) == dimension(r) ? new_quantity(typeof(l), ustrip(l) + ustrip(r), dimension(l)) : throw(DimensionError(l, r))
 Base.:-(l::AbstractQuantity) = new_quantity(typeof(l), -ustrip(l), dimension(l))
@@ -30,8 +30,8 @@ _pow(l::AbstractQuantity{T}, r) where {T} = new_quantity(typeof(l), ustrip(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::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.:^(l::AbstractQuantity{T,D}, r::Integer) where {T,R,D<:AbstractDimensions{R}} = _pow(l, r)
+Base.:^(l::AbstractQuantity{T,D}, r::Number) where {T,R,D<:AbstractDimensions{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/types.jl

@@ -1,9 +1,9 @@
 import Tricks: static_fieldnames, static_fieldtypes
 
-const DEFAULT_DIM_TYPE = FixedRational{Int32, 2^4 * 3^2 * 5^2 * 7}
+const DEFAULT_DIM_BASE_TYPE = FixedRational{Int32,2^4 * 3^2 * 5^2 * 7}
 const DEFAULT_VALUE_TYPE = Float64
 
-abstract type AbstractQuantity{T,R} end
+abstract type AbstractQuantity{T,D} end
 abstract type AbstractDimensions{R} end
 
 """
@@ -27,10 +27,10 @@ which is by default a rational number.
 
 # Constructors
 
-- `Dimensions(args...)`: Pass all the dimensions as arguments. `R` is set to `DEFAULT_DIM_TYPE`.
-- `Dimensions(; kws...)`: Pass a subset of dimensions as keyword arguments. `R` is set to `DEFAULT_DIM_TYPE`.
+- `Dimensions(args...)`: Pass all the dimensions as arguments. `R` is set to `DEFAULT_DIM_BASE_TYPE`.
+- `Dimensions(; kws...)`: Pass a subset of dimensions as keyword arguments. `R` is set to `DEFAULT_DIM_BASE_TYPE`.
 - `Dimensions(::Type{R}; kws...)` or `Dimensions{R}(; kws...)`: Pass a subset of dimensions as keyword arguments, with the output type set to `Dimensions{R}`.
-- `Dimensions{R}(args...)`: Pass all the dimensions as arguments, with the output type set to `Dimensions{R}`.
+- `Dimensions{R}()`: Create a dimensionless object typed as `Dimensions{R}`.
 - `Dimensions{R}(d::Dimensions)`: Copy the dimensions from another `Dimensions` object, with the output type set to `Dimensions{R}`.
 """
 struct Dimensions{R<:Real} <: AbstractDimensions{R}
@@ -43,18 +43,17 @@ struct Dimensions{R<:Real} <: AbstractDimensions{R}
     amount::R
 end
 
-(::Type{D})(::Type{R}; kws...) where {R,D<:AbstractDimensions} = D{R}((tryrationalize(R, get(kws, k, zero(R))) for k in static_fieldnames(D))...)
-(::Type{D})(; kws...) where {D<:AbstractDimensions} = D(DEFAULT_DIM_TYPE; kws...)
-
-(::Type{D})(args...) where {R,D<:AbstractDimensions{R}} = dimension_constructor(D)(Base.Fix1(convert, R).(args)...)
-(::Type{D})(; kws...) where {R,D<:AbstractDimensions{R}} = dimension_constructor(D)(R; kws...)
+(::Type{D})(::Type{R}; kws...) where {R,D<:AbstractDimensions} = constructor_of(D){R}((tryrationalize(R, get(kws, k, zero(R))) for k in static_fieldnames(D))...)
+(::Type{D})(; kws...) where {R,D<:AbstractDimensions{R}} = constructor_of(D)(R; kws...)
+(::Type{D})(; kws...) where {D<:AbstractDimensions} = D(DEFAULT_DIM_BASE_TYPE; kws...)
 (::Type{D})(d::AbstractDimensions) where {R,D<:AbstractDimensions{R}} = D((getproperty(d, k) for k in static_fieldnames(D))...)
 
+const DEFAULT_DIM_TYPE = Dimensions{DEFAULT_DIM_BASE_TYPE}
 
 """
-    Quantity{T,R}
+    Quantity{T,D}
 
-Physical quantity with value `value` of type `T` and dimensions `dimensions` of type `Dimensions{R}`.
+Physical quantity with value `value` of type `T` and dimensions `dimensions` of type `D`.
 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)`.
@@ -68,77 +67,37 @@ dimensions according to the operation.
 # Fields
 
 - `value::T`: value of the quantity of some type `T`. Access with `ustrip(::Quantity)`
-- `dimensions::Dimensions{R}`: dimensions of the quantity with dimension type `R`. Access with `dimension(::Quantity)`
+- `dimensions::D`: dimensions of the quantity. Access with `dimension(::Quantity)`
 
 # Constructors
 
-- `Quantity(x; kws...)`: Construct a quantity with value `x` and dimensions given by the keyword arguments. The value type is inferred from `x`. `R` is set to `DEFAULT_DIM_TYPE`.
-- `Quantity(x, ::Type{R}; kws...)`: Construct a quantity with value `x`. The dimensions parametric type is set to `R`.
-- `Quantity(x, d::Dimensions{R})`: Construct a quantity with value `x` and dimensions `d`.
-- `Quantity{T}(q::Quantity)`: Construct a quantity with value `q.value` and dimensions `q.dimensions`, but with value type converted to `T`.
-- `Quantity{T,R}(q::Quantity)`: Construct a quantity with value `q.value` and dimensions `q.dimensions`, but with value type converted to `T` and dimensions parametric type set to `R`.
+- `Quantity(x; kws...)`: Construct a quantity with value `x` and dimensions given by the keyword arguments. The value
+   type is inferred from `x`. `R` is set to `DEFAULT_DIM_TYPE`.
+- `Quantity(x, ::Type{D}; kws...)`: Construct a quantity with value `x` with dimensions given by the keyword arguments,
+   and the dimensions type set to `D`.
+- `Quantity(x, d::D)`: Construct a quantity with value `x` and dimensions `d` of type `D`.
+- `Quantity{T}(...)`: As above, but converting the value to type `T`. You may also pass a `Quantity` as input.
+- `Quantity{T,D}(...)`: As above, but converting the value to type `T` and dimensions to `D`. You may also pass a
+  `Quantity` as input.
 """
-struct Quantity{T,R} <: AbstractQuantity{T,R}
+struct Quantity{T,D<:AbstractDimensions} <: AbstractQuantity{T,D}
     value::T
-    dimensions::Dimensions{R}
-end
-
-(::Type{Q})(x, ::Type{R}; kws...) where {R,Q<:AbstractQuantity} = quantity_constructor(Q){typeof(x), R}(x, dimension_constructor(Q)(R; kws...))
-(::Type{Q})(x; kws...) where {Q<:AbstractQuantity} = Q(x, DEFAULT_DIM_TYPE; kws...)
-(::Type{Q})(q::AbstractQuantity) where {T,Q<:AbstractQuantity{T}} = new_quantity(Q, convert(T, ustrip(q)), dimension(q))
-(::Type{Q})(q::AbstractQuantity) where {T,R,Q<:AbstractQuantity{T,R}} = new_quantity(Q, convert(T, ustrip(q)), dimension_constructor(Q){R}(dimension(q)))
-
-new_dimensions(::Type{QD}, dims...) where {QD<:Union{AbstractQuantity,AbstractDimensions}} = dimension_constructor(QD)(dims...)
-new_quantity(::Type{QD}, l, r) where {QD<:Union{AbstractQuantity,AbstractDimensions}} = quantity_constructor(QD)(l, r)
-
-function constructor_of(::Type{T}) where {T}
-    return Base.typename(T).wrapper
+    dimensions::D
 end
-@generated function get_dim_type(::Type{Q}) where {Q<:AbstractQuantity}
-    quantity_type = constructor_of(Q)
-    field_type = NamedTuple(static_fieldnames(quantity_type) .=> static_fieldtypes(quantity_type))[:dimensions]
-    out = constructor_of(field_type)
-    return :($out)
-end
-
-"""
-    dimension_constructor(::Type{<:AbstractDimensions})
-
-This function returns the container for a particular `AbstractDimensions`.
-For example, `Dimensions` will get returned as `Dimensions`, and
-`Dimensions{Rational{Int64}}` will also get returned as `Dimensions`.
-"""
-dimension_constructor(::Type{D}) where {D<:AbstractDimensions} = constructor_of(D)
+(::Type{Q})(x::T, ::Type{D}; kws...) where {D<:AbstractDimensions,T,T2,Q<:AbstractQuantity{T2}} = constructor_of(Q)(convert(T2, x), D(; kws...))
+(::Type{Q})(x, ::Type{D}; kws...) where {D<:AbstractDimensions,Q<:AbstractQuantity} = constructor_of(Q)(x, D(; kws...))
+(::Type{Q})(x::T; kws...) where {T,T2,Q<:AbstractQuantity{T2}} = constructor_of(Q)(convert(T2, x), dim_type(Q)(; kws...))
+(::Type{Q})(x; kws...) where {Q<:AbstractQuantity} = constructor_of(Q)(x, dim_type(Q)(; kws...))
 
-"""
-    dimension_constructor(::Type{<:AbstractQuantity})
+(::Type{Q})(q::AbstractQuantity) where {T,D<:AbstractDimensions,Q<:AbstractQuantity{T,D}} = constructor_of(Q)(convert(T, ustrip(q)), convert(D, dimension(q)))
+(::Type{Q})(q::AbstractQuantity) where {T,Q<:AbstractQuantity{T}} = constructor_of(Q)(convert(T, ustrip(q)), dimension(q))
 
-This function returns the `Dimensions` type used inside
-a particular `Quantity` type by reading the `.dimensions` field.
-It also strips the type parameter (i.e., `Dimensions{R} -> Dimensions`).
-"""
-dimension_constructor(::Type{Q}) where {Q<:AbstractQuantity} = get_dim_type(Q)
-
-"""
-    quantity_constructor(::Type{<:AbstractQuantity})
+new_dimensions(::Type{D}, dims...) where {D<:AbstractDimensions} = constructor_of(D)(dims...)
+new_quantity(::Type{Q}, l, r) where {Q<:AbstractQuantity} = constructor_of(Q)(l, r)
 
-This function returns the container for a particular `AbstractQuantity`.
-For example, `Quantity` gets returned as `Quantity`, `Quantity{Float32}` also
-as `Quantity`, and `Quantity{Float32,Rational{Int64}}` also as `Quantity`.
-"""
-quantity_constructor(::Type{Q}) where {Q<:AbstractQuantity} = constructor_of(Q)
-
-"""
-    quantity_constructor(::Type{<:AbstractDimensions})
-
-This function returns the `<:AbstractQuantity` type corresponding to
-a given `<:AbstractDimensions`. For example, `Dimensions -> Quantity`.
-If you define a custom dimensions type, you should overload this function
-so it returns your custom quantity type that uses that dimensions type.
-This is only needed if you wish to use the `(*)(::AbstractDimensions, ::Number)`
-function; otherwise it won't be necessary.
-"""
-quantity_constructor(::Type{D}) where {D<:Dimensions} = Quantity
+dim_type(::Type{Q}) where {T,D<:AbstractDimensions,Q<:AbstractQuantity{T,D}} = D
+dim_type(::Type{<:AbstractQuantity}) = DEFAULT_DIM_TYPE
+constructor_of(::Type{T}) where {T} = Base.typename(T).wrapper
 
 struct DimensionError{Q1,Q2} <: Exception
     q1::Q1

src/utils.jl

@@ -29,17 +29,17 @@ end
 Base.float(q::AbstractQuantity{T}) where {T<:AbstractFloat} = convert(T, q)
 Base.convert(::Type{T}, q::AbstractQuantity) where {T<:Real} =
     let
-        @assert iszero(q.dimensions) "$(typeof(q)): $(q) has dimensions! Use `ustrip` instead."
-        return convert(T, q.value)
+        @assert iszero(dimension(q)) "$(typeof(q)): $(q) has dimensions! Use `ustrip` instead."
+        return convert(T, ustrip(q))
     end
 
 Base.keys(d::AbstractDimensions) = static_fieldnames(typeof(d))
 Base.getindex(d::AbstractDimensions, k::Symbol) = getfield(d, k)
 
 # Compatibility with `.*`
-Base.length(::Union{AbstractQuantity,AbstractDimensions}) = 1
-Base.iterate(qd::Union{AbstractQuantity,AbstractDimensions}) = (qd, nothing)
-Base.iterate(::Union{AbstractQuantity,AbstractDimensions}, ::Nothing) = nothing
+Base.length(::AbstractQuantity) = 1
+Base.iterate(qd::AbstractQuantity) = (qd, nothing)
+Base.iterate(::AbstractQuantity, ::Nothing) = nothing
 
 # Numeric checks
 Base.isapprox(l::AbstractQuantity, r::AbstractQuantity; kws...) = isapprox(ustrip(l), ustrip(r); kws...) && dimension(l) == dimension(r)
@@ -67,7 +67,7 @@ end
 # Base.one, typemin, typemax
 for f in (:one, :typemin, :typemax)
     @eval begin
-        Base.$f(::Type{Q}) where {T,R,Q<:AbstractQuantity{T,R}} = new_quantity(Q, $f(T), R)
+        Base.$f(::Type{Q}) where {T,D,Q<:AbstractQuantity{T,D}} = new_quantity(Q, $f(T), D)
         Base.$f(::Type{Q}) where {T,Q<:AbstractQuantity{T}} = $f(constructor_of(Q){T, DEFAULT_DIM_TYPE})
         Base.$f(::Type{Q}) where {Q<:AbstractQuantity} = $f(Q{DEFAULT_VALUE_TYPE, DEFAULT_DIM_TYPE})
     end
@@ -134,12 +134,12 @@ tryrationalize(::Type{R}, x) where {R} = isinteger(x) ? convert(R, round(Int, x)
 
 Base.showerror(io::IO, e::DimensionError) = print(io, "DimensionError: ", e.q1, " and ", e.q2, " have incompatible dimensions")
 
-Base.convert(::Type{Quantity}, q::Quantity) = q
-Base.convert(::Type{Quantity{T}}, q::Quantity) where {T} = Quantity{T}(q)
-Base.convert(::Type{Quantity{T,R}}, q::Quantity) where {T,R} = Quantity{T,R}(q)
+Base.convert(::Type{Q}, q::AbstractQuantity) where {Q<:AbstractQuantity} = q
+Base.convert(::Type{Q}, q::AbstractQuantity) where {T,Q<:AbstractQuantity{T}} = new_quantity(Q, convert(T, ustrip(q)), dimension(q))
+Base.convert(::Type{Q}, q::AbstractQuantity) where {T,D,Q<:AbstractQuantity{T,D}} = new_quantity(Q, convert(T, ustrip(q)), convert(D, dimension(q)))
 
-Base.convert(::Type{Dimensions}, d::Dimensions) = d
-Base.convert(::Type{Dimensions{R}}, d::Dimensions) where {R} = Dimensions{R}(d)
+Base.convert(::Type{D}, d::AbstractDimensions) where {D<:AbstractDimensions} = d
+Base.convert(::Type{D}, d::AbstractDimensions) where {R,D<:AbstractDimensions{R}} = D(d)
 
 """
     ustrip(q::AbstractQuantity)

test/test_unitful.jl

@@ -1,5 +1,5 @@
 import DynamicQuantities
-using DynamicQuantities: DEFAULT_DIM_TYPE, DEFAULT_VALUE_TYPE
+using DynamicQuantities: DEFAULT_DIM_BASE_TYPE, DEFAULT_VALUE_TYPE
 import Unitful
 import Unitful: @u_str
 import Ratios: SimpleRatio
@@ -11,14 +11,15 @@ risapprox(x::Unitful.Quantity, y::Unitful.Quantity; kws...) =
         return isapprox(xfloat, yfloat; kws...)
     end
 
-for T in [DEFAULT_VALUE_TYPE, Float16, Float32, Float64], R in [DEFAULT_DIM_TYPE, Rational{Int16}, Rational{Int32}, SimpleRatio{Int}, SimpleRatio{SafeInt16}]
-    x = DynamicQuantities.Quantity(T(0.2), R, length=1, amount=2, current=-1 // 2, luminosity=2 // 5)
+for T in [DEFAULT_VALUE_TYPE, Float16, Float32, Float64], R in [DEFAULT_DIM_BASE_TYPE, Rational{Int16}, Rational{Int32}, SimpleRatio{Int}, SimpleRatio{SafeInt16}]
+    D = DynamicQuantities.Dimensions{R}
+    x = DynamicQuantities.Quantity(T(0.2), D, length=1, amount=2, current=-1 // 2, luminosity=2 // 5)
     x_unitful = T(0.2)u"m*mol^2*A^(-1//2)*cd^(2//5)"
 
     @test risapprox(convert(Unitful.Quantity, x), x_unitful; atol=1e-6)
     @test typeof(convert(DynamicQuantities.Quantity, convert(Unitful.Quantity, x))) <: DynamicQuantities.Quantity{T,DynamicQuantities.DEFAULT_DIM_TYPE}
     @test isapprox(convert(DynamicQuantities.Quantity, convert(Unitful.Quantity, x)), x; atol=1e-6)
 
-    @test isapprox(convert(DynamicQuantities.Quantity{T,R}, x_unitful), x; atol=1e-6)
-    @test risapprox(convert(Unitful.Quantity, convert(DynamicQuantities.Quantity{T,R}, x_unitful)), Unitful.upreferred(x_unitful); atol=1e-6)
+    @test isapprox(convert(DynamicQuantities.Quantity{T,D}, x_unitful), x; atol=1e-6)
+    @test risapprox(convert(Unitful.Quantity, convert(DynamicQuantities.Quantity{T,D}, x_unitful)), Unitful.upreferred(x_unitful); atol=1e-6)
 end