| Copyright | Copyright (C) 2006-2018 Bjorn Buckwalter |
|---|---|
| License | BSD3 |
| Maintainer | bjorn@buckwalter.se |
| Stability | Stable |
| Portability | GHC only? |
| Safe Haskell | None |
| Language | Haskell2010 |
Numeric.Units.Dimensional.Dynamic
Description
Defines types for manipulation of units and quantities without phantom types for their dimensions.
- data AnyQuantity a
- data DynQuantity a
- class Demotable (q :: * -> *)
- class Promotable (q :: * -> *)
- class HasDynamicDimension a where
- data DynamicDimension
- promoteQuantity :: forall a d q. (Promotable q, KnownDimension d) => q a -> Maybe (Quantity d a)
- demoteQuantity :: (Demotable q, Promotable d) => q a -> d a
- (*~) :: (Floating a, Promotable q) => a -> AnyUnit -> q a
- (/~) :: (Floating a, Promotable q) => q a -> AnyUnit -> Maybe a
- invalidQuantity :: DynQuantity a
- polydimensionalZero :: Num a => DynQuantity a
- data AnyUnit
- demoteUnit :: forall m d a. KnownDimension d => Unit m d a -> AnyUnit
- promoteUnit :: forall d. KnownDimension d => AnyUnit -> Maybe (Unit NonMetric d ExactPi)
- demoteUnit' :: KnownDimension d => Unit m d ExactPi -> AnyUnit
- siUnit :: Dimension' -> AnyUnit
- anyUnitName :: AnyUnit -> UnitName NonMetric
- (*) :: AnyUnit -> AnyUnit -> AnyUnit
- (/) :: AnyUnit -> AnyUnit -> AnyUnit
- (^) :: Integral a => AnyUnit -> a -> AnyUnit
- recip :: AnyUnit -> AnyUnit
- applyPrefix :: Prefix -> AnyUnit -> Maybe AnyUnit
Dynamic Quantities
data AnyQuantity a #
Instances
| Promotable AnyQuantity # | |
| Demotable AnyQuantity # | |
| Eq a => Eq (AnyQuantity a) # | |
| Data a => Data (AnyQuantity a) # | |
| Show a => Show (AnyQuantity a) # | |
| Generic (AnyQuantity a) # | |
| Num a => Semigroup (AnyQuantity a) # |
|
| Num a => Monoid (AnyQuantity a) # |
|
| NFData a => NFData (AnyQuantity a) # | |
| HasDimension (AnyQuantity a) # | |
| HasDynamicDimension (AnyQuantity a) # | |
| Generic1 * AnyQuantity # | |
| type Rep (AnyQuantity a) # | |
| type Rep1 * AnyQuantity # | |
data DynQuantity a #
Possibly a Quantity whose Dimension is only known dynamically.
By modeling the absence of a value, this type differs from AnyQuantity in that it may
not be a Quantity of any Dimension whatsoever, but in exchange it gains instances
for the common numeric classes. It's therefore useful for manipulating, and not merely storing,
quantities of unknown dimension.
This type also contains a polydimensionalZero, representing zero value of any dimension.
Note that the Eq instance for DynQuantity equates all representations of an invalid value,
and also does not equate polydimensional zero with zero of any specific dimension.
Instances
| Promotable DynQuantity # | |
| Eq a => Eq (DynQuantity a) # | |
| Floating a => Floating (DynQuantity a) # | |
| Fractional a => Fractional (DynQuantity a) # | |
| Data a => Data (DynQuantity a) # | |
| Num a => Num (DynQuantity a) # | |
| Show a => Show (DynQuantity a) # | |
| Generic (DynQuantity a) # | |
| Num a => Semigroup (DynQuantity a) # |
|
| Num a => Monoid (DynQuantity a) # |
|
| NFData a => NFData (DynQuantity a) # | |
| HasDynamicDimension (DynQuantity a) # | |
| Generic1 * DynQuantity # | |
| type Rep (DynQuantity a) # | |
| type Rep1 * DynQuantity # | |
class Demotable (q :: * -> *) #
The class of types that can be used to model Quantitys that are certain to have a value with
some dimension.
Minimal complete definition
demotableOut
Instances
| Demotable AnyQuantity # | |
| KnownDimension d => Demotable (Quantity d) # | |
class HasDynamicDimension a where #
Dimensional values, or those that are only possibly dimensional, inhabit this class, which allows access to a term-level representation of their dimension.
Methods
dynamicDimension :: a -> DynamicDimension #
Gets the 'DynamicDimension of a dynamic dimensional value, which may be NoDimension if it does not represent
a dimensional value of any Dimension.
A default implementation is available for types that are also in the HasDimension typeclass.
dynamicDimension :: HasDimension a => a -> DynamicDimension #
Gets the 'DynamicDimension of a dynamic dimensional value, which may be NoDimension if it does not represent
a dimensional value of any Dimension.
A default implementation is available for types that are also in the HasDimension typeclass.
Instances
| HasDynamicDimension DynamicDimension # | |
| HasDynamicDimension Dimension' # | |
| HasDynamicDimension AnyUnit # | |
| HasDynamicDimension (DynQuantity a) # | |
| HasDynamicDimension (AnyQuantity a) # | |
| (KnownTypeInt l, KnownTypeInt m, KnownTypeInt t, KnownTypeInt i, KnownTypeInt th, KnownTypeInt n, KnownTypeInt j) => HasDynamicDimension (Proxy Dimension (Dim l m t i th n j)) # | |
| KnownDimension d => HasDynamicDimension (Dimensional v d a) # | |
data DynamicDimension #
The dimension of a dynamic value, which may not have any dimension at all.
Constructors
| NoDimension | The value has no valid dimension. |
| SomeDimension Dimension' | The value has the given dimension. |
| AnyDimension | The value may be interpreted as having any dimension. |
promoteQuantity :: forall a d q. (Promotable q, KnownDimension d) => q a -> Maybe (Quantity d a) #
Converts a dynamic quantity such as an AnyQuantity or a DynQuantity into a
Quantity, or to Nothing if the dynamic quantity cannot be represented in the
narrower result type.
demoteQuantity :: (Demotable q, Promotable d) => q a -> d a #
Forgets information about a Quantity or AnyQuantity, yielding an AnyQuantity or a DynQuantity.
(*~) :: (Floating a, Promotable q) => a -> AnyUnit -> q a #
Forms a dynamic quantity by multipliying a number and a dynamic unit.
(/~) :: (Floating a, Promotable q) => q a -> AnyUnit -> Maybe a #
Divides a dynamic quantity by a dynamic unit, obtaining the numerical value of the quantity
expressed in that unit if they are of the same physical dimension, or Nothing otherwise.
invalidQuantity :: DynQuantity a #
A DynQuantity which does not correspond to a value of any dimension.
polydimensionalZero :: Num a => DynQuantity a #
A DynQuantity which corresponds to zero value of any dimension.
When combined through arithmetic with other DynQuantitys, inference is performed. For example,
adding a length to polydimensional zero produces that length. Adding two polydimensional zeros produces another.
Taking the sine of a polydimensional zero interprets it as a dimensionless zero and produces a dimensionless result.
Note that division by polydimensionalZero produces a polydimensional result, which may be an error or some representation
of infinity, as determined by the underlying arithmetic type. This behavior was chosen for consistency with the behavior of division
by zero DynQuantitys of a specific dimension.
Dynamic Units
demoteUnit :: forall m d a. KnownDimension d => Unit m d a -> AnyUnit #
promoteUnit :: forall d. KnownDimension d => AnyUnit -> Maybe (Unit NonMetric d ExactPi) #
Converts an AnyUnit into a Unit of statically known Dimension, or Nothing if the dimension does not match.
The result is represented in ExactPi, conversion to other representations is possible using changeRepApproximate.
The result is always tagged as NonMetric, conversion to a Metric unit can be attempted using strengthen.
demoteUnit' :: KnownDimension d => Unit m d ExactPi -> AnyUnit #
Converts a Unit of statically known Dimension into an AnyUnit.
This is the same as the more general demoteUnit but is useful in certain circumstances to avoid
needlessly introducing an ambiguous type variable.
siUnit :: Dimension' -> AnyUnit #
The dynamic SI coherent unit of a given dimension.
anyUnitName :: AnyUnit -> UnitName NonMetric #