Quantities

AbstractQuantityType{T}

Alias for Union{AbstractQuantity{T}, AbstractQuantityArray{T}} where T<:Number.

SimpleQuantityType{T}

Alias for Union{SimpleQuantity{T}, SimpleQuantityArray{T}} where T<:Number.

QuantityType{T}

Alias for Union{Quantity{T}, QuantityArray{T}} where T<:Number.

DimensionlessType{T}

Type union representing numbers and number arrays.

Alias for Union{Number, AbstractArray{<:Number}}.

InternalUnits

A set of seven SimpleQuantity objects which represent a choice of units with respect to which the seven basic physical dimensions of the SI system are measured.

Fields

• mass::SimpleQuantity: unit of mass
• length::SimpleQuantity: unit of length
• time::SimpleQuantity: unit of time
• current::SimpleQuantity: unit of current
• temperature::SimpleQuantity: unit of temperature
• amount::SimpleQuantity: unit of amount
• luminousIntensity::SimpleQuantity: unit of luminousIntensity

Constructors

InternalUnits(::SimpleQuantity, ::SimpleQuantity, ::SimpleQuantity, ::SimpleQuantity, ::SimpleQuantity, ::SimpleQuantity, ::SimpleQuantity)
InternalUnits(; mass = 1*kilogram, length = 1*meter, time = 1*second, current = 1*ampere,temperature = 1*kelvin, amount = 1*mol, luminousIntensity = 1*candela)

# Raises Exceptions
- `Core.DomainError`: if attempting to initialize any field with a quantity
of a value that is zero, infinite, or not real
- `Exceptions.DimensionMismatchError`: if attempting to initialize any field
with a quantity whose dimension does not match the physical dimension the field
represents

# Examples
The following `InternalUnits` measure lengths in units of ``3 cm`` and uses
the basic SI units for all other dimensions:

jldoctest julia> ucat = UnitCatalogue(); cm = ucat.centi * ucat.meter ;

julia> InternalUnits(length = 3cm) InternalUnits mass unit: 1 kg length unit: 3 cm time unit: 1 s current unit: 1 A temperature unit: 1 K amount unit: 1 mol luminous intensity unit: 1 cd ```

Base.:(==)(internalUnits1::InternalUnits, internalUnits2::InternalUnits)

Compare two InternalUnits objects.

Two InternalUnits objects are equal if the SimpleQuantity objects representing the unit for each of the seven physical dimensions are equal.

internalUnitFor(dimension::Dimension, internalUnits::InternalUnits)

Returns a SimpleQuantity representing the unit in which quantities of physical dimension dimension are measured according to internalUnits.

conversionFactor(dimension::Dimension, currentIntU::InternalUnits, targetIntU::InternalUnits)

Returns the factor with which a value of physical dimension dimension expressed in units of currentIntU needs to be mutliplied in order to express it in units of targetIntU.

AbstractQuantity{T<:Number}

Abstract supertype for all quantities that have a scalar value (number) of type T.

SimpleQuantity{T<:Number} <: AbstractQuantity{T}

A physical quantity consisting of a scalar value and a physical unit.

Fields

• value::T: value of the quantity
• unit::Unit: unit of the quantity

Constructors

SimpleQuantity(::Number, ::AbstractUnit)
SimpleQuantity(::Number)
SimpleQuantity(::AbstractUnit)

If no unit is passed to the constructor, unitlessUnit is used by default. If no value is passed to the constructor, the value is set to 1 by default.

If called with a Quantity as argument, the Quantity is expressed in terms of the units used to store its value internally, see InternalUnits.

SimpleQuantity(::Quantity)

If the type T is specified explicitly, Alicorn attempts to convert the value accordingly:

SimpleQuantity{T}(::Number, ::AbstractUnit) where {T<:Number}
SimpleQuantity{T}(::Number) where {T<:Number}
SimpleQuantity{T}(::AbstractUnit) where {T<:Number}

Examples

1. The quantity $7\,\mathrm{nm}$ (seven nanometers) can be constructed using the constructor method as follows:

   julia> ucat = UnitCatalogue() ;
   
   julia> nanometer = ucat.nano * ucat.meter
   UnitFactor nm
   
   julia> quantity = SimpleQuantity(7, nanometer)
   7 nm

2. Alternatively, $7\,\mathrm{nm}$ can be constructed arithmetically:

   julia> ucat = UnitCatalogue() ;
   
   julia> nm = ucat.nano * ucat.meter
   UnitFactor nm
   
   julia> quantity = 7nm
   7 nm

Quantity{T<:Number} <: AbstractQuantity{T}

A physical quantity consisting of a number, a Dimension object representing the physical dimension, and an InternalUnits object representing the units with respect to which the seven basic dimensions of the SI system are measured.

The value field of a Quantity{T} is of type T, which needs to be a subtype of Number.

Fields

• value::T: value of the quantity
• dimension::Dimension: physical dimension of the quantity
• internalUnits::InternalUnits: set of units with respect to which the seven

basic dimensions of the SI system are measured.

Constructors

The constructors preserve the type T of the value upon conversion to the internal units whenever possible. If no InternalUnits are passed to the constructor, the basic SI units are used by default.

Construction from value and dimension; if no dimension is passed to the constructor, a dimensionless quantity is constructed by default.

Quantity(::Number, ::Dimension, ::InternalUnits)
Quantity(::Number, ::Dimension)
Quantity(::Number, ::InternalUnits)
Quantity(::Number)

If the type T is specified explicitly, Alicorn attempts to convert the value accordingly:

Quantity{T}(::Number, ::Dimension, ::InternalUnits) where {T<:Number}
Quantity{T}(::Number, ::Dimension) where {T<:Number}
Quantity{T}(::Number, ::InternalUnits) where {T<:Number}
Quantity{T}(::Number) where {T<:Number}

Construction from value and unit; if no unit is passed to the constructor, a dimensionless quantity is constructed by default.

Quantity(::Number, ::AbstractUnit, ::InternalUnits)
Quantity(::Number, ::AbstractUnit)
Quantity(::AbstractUnit, ::InternalUnits)
Quantity(::AbstractUnit)

Examples

1. The quantity $7\,\mathrm{nm}$ (seven nanometers) can for instance be constructed as follows:

   julia> ucat = UnitCatalogue() ;
          nm = ucat.nano*ucat.meter;
          intu = InternalUnits(length=1nm) ;
   
   julia> Quantity(7nm, intu)
   Quantity{Int64} of dimension L^1 in units of (1 nm):
    7

   Note that the original type Int64 of the value is preserved.

2. If we use $2\,\mathrm{nm}$ as internal unit for length, the value can no longer be represented as type Int64 internally:

   julia> ucat = UnitCatalogue() ;
          nm = ucat.nano*ucat.meter;
          intu = InternalUnits(length=2nm) ;
   
   julia> Quantity(7nm, intu)
   Quantity{Float64} of dimension L^1 in units of (2 nm):
    3.5

ScalarQuantity{T}

Type union representing a scalar (number) of type T, with or without a unit.

Alias for Union{T, AbstractQuantity{T}} where T<:Number.

Base.:*(value::Number, abstractUnit::AbstractUnit)

Combine value and abstractUnit to form a physical quantity of type SimpleQuantity.

If abstractUnit is a product of a UnitPrefix and BaseUnit, they are first combined into a SimpleQuantity, which is then in turn combined with value.

Example

julia> ucat = UnitCatalogue() ;

julia> 3.5 * ucat.milli * ucat.tesla
3.5 mT

Base.:/(value::Number, abstractUnit::AbstractUnit)

Combine value and abstractUnit to form a physical quantity of type SimpleQuantity.

If abstractUnit is a product of a UnitPrefix and BaseUnit, they are first combined into a SimpleQuantity, which is then in turn combined with value.

Example

julia> ucat = UnitCatalogue() ;

julia> 3.5 / ucat.nano * ucat.second
3.5 ns^-1

dimensionOf(quantity::AbstractQuantity)

Returns the dimension of a physical quantity of type AbstractQuantity.

Example

One henry is defined as $1\,\mathrm{H} = 1\,\mathrm{kg}^{1}\,\mathrm{m}^{2}\,\mathrm{s}^{-2}\,\mathrm{A}^{-2}$ and is hence of dimension $\mathrm{M}^{1}\,\mathrm{L}^{2}\,\mathrm{T}^{-2}\,\mathrm{I}^{-2}$:

julia> ucat = UnitCatalogue() ;

julia> oneHenry = 1 * ucat.henry
1 H
julia> dimensionOf(oneHenry)
Dimension M^1 L^2 T^-2 I^-2

SimpleQuantity(quantity::AbstractQuantity)

Construct a SimpleQuantity from a physical quantity of any implementation of AbstractQuantity.

If quantity is of type SimpleQuantity, it is returned unchanged. If quantity is of type Quantity, it is expressed in terms of the SI units specified by quantity.InternalUnits.

Example

julia> ucat = UnitCatalogue() ; intu = InternalUnits(length=2*ucat.milli*ucat.meter) ;

julia> q = Quantity(4, Dimension(L=1), intu)
Quantity{Int64} of dimension L^1 in units of (2 mm):
 4
julia> sq = SimpleQuantity(q)
8 mm

SimpleQuantity{T}(::AbstractQuantity) where {T<:Number}

Construct a SimpleQuantity{T} with specified type T from a physical quantity of any implementation of AbstractQuantity.

See SimpleQuantity(::AbstractQuantity) for details.

Quantity(::AbstractQuantity, ::InternalUnits)
Quantity(::AbstractQuantity)

Construct a Quantity from a physical quantity of any implementation of AbstractQuantity.

If no InternalUnits are specified, they are constructed using basic SI units.

Quantity{T}(::AbstractQuantity, ::InternalUnits) where {T<:Number}
Quantity{T}(::AbstractQuantity) where {T<:Number}

Construct a Quantity{T} with specified type T from a physical quantity of any implementation of AbstractQuantity.

See Quantity(::AbstractQuantity, ::InternalUnits) for details.

Raises Exceptions

• InexactError: if the internal value of AbstractQuantity cannot be

represented as type T.

Base.convert(::Type{T}, simpleQuantity::SimpleQuantity) where {T<:SimpleQuantity}

Convert simpleQuantity from type SimpleQuantity{S} where S to any subtype T of SimpleQuantity

Allows to convert, for instance, from SimpleQuantity{Float64} to SimpleQuantity{UInt8}.

Base.convert(::Type{T}, quantity::Quantity) where {T<:Quantity}

Convert quantity from type Quantity{S} where S to any type T of Quantity.

Allows to convert, for instance, from Quantity{Float64} to Quantity{UInt8}.

inUnitsOf(quantity::AbstractQuantity, unit::AbstractUnit)::SimpleQuantity

Express quantity as an object of type SimpleQuantity in terms of the unit specified by unit.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if the dimensions of quantity and unit do not agree

inBasicSIUnits(quantity::AbstractQuantity)::SimpleQuantity

Express quantity as an object of type SimpleQuantity using the seven basic SI units.

valueInUnitsOf(quantity::AbstractQuantity, unit::AbstractUnit)

Returns the numerical value of quantity expressed in units of unit.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if the dimensions of quantity and unit do not agree

valueInUnitsOf(quantity::AbstractQuantity, simpleQuantity::SimpleQuantity)

Returns the numerical value of quantity expressed in units of simpleQuantity.

The result is equivalent to valueOfDimensionless(quantity / simpleQuantity).

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if the dimensions of quantity and simpleQuantity do not agree

valueOfDimensionless(quantity::AbstractQuantity)

Strips the unit from a dimensionless quantity and returns its bare value.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if quantity is not dimensionless

Base.:*(quantity::AbstractQuantity, unit::AbstractUnit)
Base.:*(unit::AbstractUnit, quantity::AbstractQuantity)

Modify the unit of quantity by multiplying it with unit.

Base.:/(quantity::AbstractQuantity, unit::AbstractUnit)
Base.:/(unit::AbstractUnit, quantity::AbstractQuantity)

Modify the unit of quantity by dividing it by unit, or vice versa.

inInternalUnitsOf(qArray::QuantityArray{T}, targetIntU::InternalUnits) where T

Returns a new QuantityArray corresponding to qArray, but stored using targetIntU as new internal units.

The value type S of the returned quantity array is identical to T, if possible.

AbstractQuantity{T,N} <: AbstractArray{T,N}

Abstract supertype for all array-valued quantities of dimension N and with elements of type T.

AbstractQuantityVector{T}

Abstract supertype for one-dimensional array-valued quantities with elements of type T.

Alias for AbstractQuantityArray{T,1}.

AbstractQuantityMatrix{T}

Abstract supertype for two-dimensional array-valued quantities with elements of type T.

Alias for AbstractQuantityArray{T,2}.

SimpleQuantityArray{T<:Number,N} <: AbstractQuantityArray{T,N}

A physical quantity consisting of a number array and a physical unit.

The value field of a SimpleQuantityArray{T,N} is of type Array{T,N}. T needs to be a subtype of Number.

Fields

• value::Array{T,N}: value of the quantity
• unit::Unit: unit of the quantity

Constructors

SimpleQuantityArray(::AbstractArray, ::AbstractUnit)
SimpleQuantityArray(::AbstractArray)

If no unit is passed to the constructor, unitlessUnit is used by default.

SimpleQuantityArray{T}(::AbstractArray, ::AbstractUnit) where {T<:Number}
SimpleQuantityArray{T}(::AbstractArray) where {T<:Number}

If the type T is specified explicitly, Alicorn attempts to convert the value accordingly.

SimpleQuantityVector{T}

One-dimensional array-valued simple quantity with elements of type T.

Alias for SimpleQuantityArray{T,1}.

SimpleQuantityMatrix{T}

Two-dimensional array-valued simple quantity with elements of type T.

Alias for SimpleQuantityArray{T,2}.

QuantityArray{T<:Number,N} <: AbstractQuantityArray{T,N}

A physical quantity consisting of an array, a Dimension object representing the physical dimension, and an InternalUnits object representing the units with respect to which the seven basic dimensions of the SI system are measured.

The value field of a QuantityArray{T,N} is of type Array{T,N}. T needs to be a subtype of Number.

Fields

• value::Array{T,N}: value of the quantity
• dimension::Dimension: physical dimension of the quantity
• internalUnits::InternalUnits: set of units with respect to which the seven

basic dimensions of the SI system are measured.

Constructors

QuantityArray(::AbstractArray, ::Dimension, ::InternalUnits)
QuantityArray(::AbstractArray, ::Dimension)
QuantityArray(::AbstractArray, ::InternalUnits)
QuantityArray(::AbstractArray)

If no InternalUnits are passed to the constructor, the basic SI units are used. If no Dimension is passed to the constructor, a dimensionless quantity is constructed.

QuantityArray{T}(::AbstractArray, ::Dimension, ::InternalUnits) where {T<:Number}
QuantityArray{T}(::AbstractArray, ::Dimension) where {T<:Number}
QuantityArray{T}(::AbstractArray, ::InternalUnits) where {T<:Number}
QuantityArray{T}(::AbstractArray) where {T<:Number}

If the type T is specified explicitly, Alicorn attempts to convert the provided AbstractArray to Array{T}.

QuantityVector{T}

One-dimensional array-valued quantity with elements of type T.

Alias for QuantityArray{T,1}.

QuantityMatrix{T}

Two-dimensional array-valued quantity with elements of type T.

Alias for QuantityArray{T,2}.

VectorQuantity{T}

Type union representing one-dimensional arrays with elements of type T, with or without a physical unit.

Alias for Union{Vector{T}, AbstractQuantityArray{T, 1}} where T<:Number.

MatrixQuantity{T}

Type union representing two-dimensional arrays with elements of type T, with or without a physical unit.

Alias for Union{Matrix{T}, AbstractQuantityArray{T, 2}} where T<:Number.

ArrayQuantity{T,N}

Type union representing N-dimensional arrays with elements of type T, with or without a physical unit.

Alias for Union{Array{T,N}, AbstractQuantityArray{T,N}} where {T<:Number, N}.

Base.:*(value::AbstractArray{T}, abstractUnit::AbstractUnit) where {T<:Number}

Combine the array value and abstractUnit to form a physical quantity of type SimpleQuantityArray.

If abstractUnit is a product of a UnitPrefix and BaseUnit, they are first combined into a SimpleQuantity, which is then in turn combined with value.

Example

julia> ucat = UnitCatalogue() ;

julia> [3.5, 4.6] * ucat.milli * ucat.tesla
2-element SimpleQuantityVector{Float64} of unit mT:
 3.5
 4.6

Base.:/(value::AbstractArray{T}, abstractUnit::AbstractUnit) where {T<:Number}

Combine the array value and abstractUnit to form a physical quantity of type SimpleQuantityArray.

If abstractUnit is a product of a UnitPrefix and BaseUnit, they are first combined into a SimpleQuantity, which is then in turn combined with value.

Example

julia> ucat = UnitCatalogue() ;

julia> [3.5, 4.6] / ucat.nano * ucat.second
2-element SimpleQuantityVector{Float64} of unit ns^-1:
 3.5
 4.6

dimensionOf(quantityArray::AbstractQuantityArray)

Returns the dimension of a physical quantity of type AbstractQuantityArray, analogous to dimensionOf(::AbstractQuantity) ```

SimpleQuantityArray(quantityArray::AbstractQuantityArray)

Construct a SimpleQuantityArray from a physical quantity of any implementation of AbstractQuantityArray.

If quantityArray is of type SimpleQuantityArray, it is returned unchanged. If quantityArray is of type QuantityArray, it is expressed in terms of the SI units specified by quantityArray.InternalUnits.

SimpleQuantityArray{T}(::AbstractQuantityArray) where {T<:Number}

Construct a SimpleQuantityArray{T} with specified type T from a physical quantity of any implementation of AbstractQuantityArray.

See SimpleQuantityArray(::AbstractQuantityArray) for details.

Raises Exceptions

• InexactError: if the value of AbstractQuantityArray cannot be

represented as type Array{T}.

SimpleQuantityArray(quantity::AbstractQuantity)

Construct a 1x1 SimpleQuantityArray from a physical quantity of any implementation of AbstractQuantity.

See SimpleQuantityArray(::AbstractQuantityArray) for details.

SimpleQuantityArray{T}(quantity::AbstractQuantity) where {T<:Number}

Construct a 1x1 SimpleQuantityArray{T} with specified type T from a physical quantity of any implementation of AbstractQuantity.

See SimpleQuantityArray(::AbstractQuantity) for details.

Raises Exceptions

• InexactError: if the value of AbstractQuantity cannot be

represented as type Array{T}.

QuantityArray(::AbstractQuantityArray, ::InternalUnits)
QuantityArray(::AbstractQuantityArray)

Construct a QuantityArray from a physical quantity of any implementation of AbstractQuantityArray.

If no InternalUnits are specified, they are inferred from the AbstractQuantityArray if possible. Else, basic SI units are used.

QuantityArray{T}(::AbstractQuantityArray, ::InternalUnits) where {T<:Number}
QuantityArray{T}(::AbstractQuantityArray) where {T<:Number}

Construct a QuantityArray{T} with specified type T from a physical quantity of any implementation of AbstractQuantityArray.

See QuantityArray(::AbstractQuantityArray, ::InternalUnits) for details.

Raises Exceptions

• InexactError: if the internal value of AbstractQuantityArray cannot be

represented as type Array{T}.

QuantityArray(quantity::AbstractQuantity, ::InternalUnits)
QuantityArray(quantity::AbstractQuantity)

Construct a 1x1 QuantityArray from a physical quantity of any implementation of AbstractQuantity.

See QuantityArray(::AbstractQuantityArray) for details.

QuantityArray{T}(::AbstractQuantity, ::InternalUnits) where {T<:Number}
QuantityArray{T}(::AbstractQuantity) where {T<:Number}

Construct a QuantityArray{T} with specified type T from a physical quantity of any implementation of AbstractQuantity.

See QuantityArray(::AbstractQuantity, ::InternalUnits) for details.

Raises Exceptions

• InexactError: if the internal value of AbstractQuantityArray cannot be

represented as type Array{T}.

Base.convert(::Type{T}, sqArray::SimpleQuantityArray) where {T<:SimpleQuantityArray}

Convert sqArray from type SimpleQuantityArray{S} where S to any subtype T of SimpleQuantityArray.

Allows to convert, for instance, from SimpleQuantityArray{Float64} to SimpleQuantityVector{UInt8}.

Base.convert(::Type{T}, qArray::QuantityArray) where {T<:QuantityArray}

Convert qArray from type QuantityArray{S} where S to any subtype T of QuantityArray.

Allows to convert, for instance, from QuantityArray{Float64} to QuantityVector{UInt8}.

inUnitsOf(qArray::AbstractQuantityArray, unit::AbstractUnit)::SimpleQuantityArray

Express qArray as an object of type SimpleQuantityArray in terms of the unit specified by unit.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if the dimensions of qArray and unit do not agree

inBasicSIUnits(qArray::AbstractQuantity)::SimpleQuantityArray

Express qArray as an object of type SimpleQuantityArray using the seven basic SI units.

valueInUnitsOf(qArray::AbstractQuantityArray, unit::AbstractUnit)

Returns the numerical value of qArray expressed in units of unit.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if the dimensions of quantity and unit do not agree

valueInUnitsOf(quantityArray::AbstractQuantityArray, simpleQuantity::SimpleQuantity)

Returns the numerical value of quantityArray expressed in units of simpleQuantity.

The result is equivalent to valueOfDimensionless(quantityArray / simpleQuantity).

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if the dimensions of quantityArray and simpleQuantity do not agree

valueOfDimensionless(qArray::AbstractQuantityArray)

Strips the unit from a dimensionless quantity array and returns its bare value.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if qArray is not dimensionless

Base.:*(qArray::AbstractQuantityArray, unit::AbstractUnit)
Base.:*(unit::AbstractUnit, qArray::AbstractQuantityArray)

Modify the unit of qArray by multiplying it with unit.

Base.:/(qArray::AbstractQuantityArray, unit::AbstractUnit)
Base.:/(unit::AbstractUnit, qArray::AbstractQuantityArray)

Modify the unit of qArray by dividing it by unit, or vice versa.

inInternalUnitsOf(quantity::Quantity{T}, targetIntU::InternalUnits) where T

Returns a new Quantity{S} corresponding to quantity, but stored using targetIntU as new internal units.

The value type S of the returned quantity is identical to T, if possible.

Base.:+(q1::SimpleQuantity, q2::SimpleQuantity)
Base.:+(q1::SimpleQuantityArray, q2::SimpleQuantityArray)

Add two objects of type SimpleQuantity or SimpleQuantityArray.

The resulting quantity is expressed in units of q1.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if q1 and q2 are of different dimensions

Base.:+(q1::Quantity, q2::Quantity)
Base.:+(q1::QuantityArray, q2::QuantityArray)

Add two objects of type Quantity or QuantityArray.

The resulting quantity is expressed in internal units of q1.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if q1 and q2 are of different dimensions

Base.:+(q1::SimpleQuantity, q2::Quantity)
Base.:+(q1::Quantity, q2::SimpleQuantity)
Base.:+(q1::SimpleQuantityArray, q2::QuantityArray)
Base.:+(q1::QuantityArray, q2::SimpleQuantityArray)

Add two objects of type SimpleQuantity and Quantity, or SimpleQuantityArray and QuantityArray.

Returns a quantity of type Quantity or QuantityArray.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if q1 and q2 are of different dimensions

Base.:-(q1::SimpleQuantity, q2::SimpleQuantity)
Base.:-(q1::SimpleQuantityArray, q2::SimpleQuantityArray)

Subtract two objects of type SimpleQuantity or SimpleQuantityArray.

The resulting quantity is expressed in units of q1.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if q1 and q2 are of different dimensions

Base.:-(q1::Quantity, q2::Quantity)
Base.:-(q1::QuantityArray, q2::QuantityArray)

Subtract two objects of type Quantity or QuantityArray.

The resulting quantity is expressed in internal units of q1.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if q1 and q2 are of different dimensions

Base.:-(q1::SimpleQuantity, q2::Quantity)
Base.:-(q1::Quantity, q2::SimpleQuantity)
Base.:-(q1::SimpleQuantityArray, q2::QuantityArray)
Base.:-(q1::QuantityArray, q2::SimpleQuantityArray)

Subtract two objects of type SimpleQuantity and Quantity, or SimpleQuantityArray and QuantityArray.

Returns a quantity of type Quantity or QuantityArray.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if q1 and q2 are of different dimensions

Base.:(==)(q1::SimpleQuantity, q2::SimpleQuantity)
Base.:(==)(q1::SimpleQuantityArray, q2::SimpleQuantityArray)

Returns true if q1 and q2 are of equal value and unit.

Note that the units are not converted during the comparison.

Examples

julia> ucat = UnitCatalogue() ;

julia> q1 = 7 * ucat.meter
7 m

julia> q2 = 700 * (ucat.centi * ucat.meter)
700 cm

julia> q1 == q1
true

julia> q1 == q2
false

Base.:(==)(q1::Quantity, q2::Quantity)
Base.:(==)(q1::QuantityArray, q2::QuantityArray)

Compare two Quantity or QuantityArray objects.

The two quantities are equal if their values, their dimensions, and their internal units are equal. Note that the internal units are not converted during the comparison.

Base.isless(q1::SimpleQuantity, q2::SimpleQuantity)

Returns true if q1 is of lesser value than q2.

Note that units are not converted during the comparison.

Raises Exceptions

• Alicorn.Exceptions.UnitMismatchError: if q1 and

q2 are not of the same unit

Base.isless(q1::Quantity, q2::Quantity)

Returns true if q1 is of lesser value than q2.

Note that internal units are not converted during the comparison.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if q1 and q2 are not of the same dimension
• Alicorn.Exceptions.UnitMismatchError: if q1 and q2 are not using the same internal units

Base.isapprox(q1::SimpleQuantity, q2::SimpleQuantity; rtol::Real = sqrt(eps()) )
Base.isapprox(q1::SimpleQuantityArray, q2::SimpleQuantityArray; rtol::Real = sqrt(eps()) )

Returns isapprox(q1.value, q2.value, rtol=rtol).

Note that units are not converted during the comparison. Returns false if the two quantities are not of equal physical dimension.

Base.isapprox(q1::Quantity, q2::Quantity; rtol::Real = sqrt(eps()) )
Base.isapprox(q1::QuantityArray, q2::QuantityArray; rtol::Real = sqrt(eps()) )

Returns isapprox(q1.value, q2.value, rtol=rtol).

Note that internal units are not converted during the comparison.

Raises Exceptions

• Alicorn.Exceptions.DimensionMismatchError: if q1 and q2 are not of the same dimension
• Alicorn.Exceptions.UnitMismatchError: if q1 and q2 are not using the same internal units