Copyright | (c) Justus Sagemüller 2022 |
---|---|
License | GPL v3 |
Maintainer | (@) jsag $ hvl.no |
Stability | experimental |
Portability | portable |
Safe Haskell | Safe-Inferred |
Language | Haskell2010 |
Synopsis
- data DimensionalityWitness v where
- IsStaticDimensional :: n `Dimensional` v => DimensionalityWitness v
- IsFlexibleDimensional :: StaticDimension v ~ 'Nothing => DimensionalityWitness v
- class VectorSpace v => DimensionAware v where
- type StaticDimension v :: Maybe Nat
- dimensionalityWitness :: DimensionalityWitness v
- class (DimensionAware v, StaticDimension v ~ 'Just n) => Dimensional n v | v -> n where
- knownDimensionalitySing :: Sing n
- unsafeFromArrayWithOffset :: Vector α (Scalar v) => Int -> α (Scalar v) -> v
- unsafeWriteArrayWithOffset :: Vector α (Scalar v) => Mutable α σ (Scalar v) -> Int -> v -> ST σ ()
- data DimensionalityCases v where
- StaticDimensionalCase :: (KnownNat n, n `Dimensional` v) => DimensionalityCases v
- FlexibleDimensionalCase :: StaticDimension v ~ 'Nothing => DimensionalityCases v
- type Dimension v = FromJust (StaticDimension v)
- class DimensionAware v => StaticDimensional v where
- dimensionIsStatic :: forall r. (forall n. (KnownNat n, n `Dimensional` v) => r) -> r
- dimensionalitySing :: forall v n. n `Dimensional` v => Sing n
- dimensionality :: forall v. DimensionAware v => DimensionalityCases v
- dimension :: forall v n a. (n `Dimensional` v, Integral a) => a
- dimensionOf :: forall v n a. (n `Dimensional` v, Integral a) => v -> a
- unsafeFromArray :: forall v n α. (n `Dimensional` v, Vector α (Scalar v)) => α (Scalar v) -> v
- fromArray :: forall v n α. (n `Dimensional` v, Vector α (Scalar v)) => α (Scalar v) -> Maybe v
- toArray :: forall v n α. (n `Dimensional` v, Vector α (Scalar v)) => v -> α (Scalar v)
- staticDimensionSing :: forall v. DimensionAware v => Sing (StaticDimension v)
- scalarUnsafeFromArrayWithOffset :: (v ~ Scalar v, Vector α v) => Int -> α v -> v
- scalarUnsafeWriteArrayWithOffset :: (v ~ Scalar v, Vector α v) => Mutable α σ v -> Int -> v -> ST σ ()
- unsafeFromArrayWithOffsetViaList :: forall v n α. (n `Dimensional` v, Vector α (Scalar v)) => ([Scalar v] -> v) -> Int -> α (Scalar v) -> v
- unsafeWriteArrayWithOffsetViaList :: forall v n α σ. (n `Dimensional` v, Vector α (Scalar v)) => (v -> [Scalar v]) -> Mutable α σ (Scalar v) -> Int -> v -> ST σ ()
- notStaticDimensionalContradiction :: forall v n r. StaticDimension v ~ 'Nothing => r
Documentation
data DimensionalityWitness v where Source #
Low-level case distinction between spaces with a dimension that is both fixed and low enough that it makes sense to treat it this way, and more general spaces where this is not feasible.
Use this type only when defining instances of DimensionAware
. When making
decisions based on dimensionality, DimensionalityCases
is more convenient.
IsStaticDimensional :: n `Dimensional` v => DimensionalityWitness v | |
IsFlexibleDimensional :: StaticDimension v ~ 'Nothing => DimensionalityWitness v |
class VectorSpace v => DimensionAware v where Source #
This class does not really pose any restrictions on a vector space type, but allows it to express its dimension. This is for optimisation purposes only, specifically to allow low-dimensional vectors to be represented efficiently in unboxed arrays / matrices.
type StaticDimension v :: Maybe Nat Source #
If this is Nothing
,
it can mean the dimension is infinite, or just big, or simply unknown / not
considered in the implementation.
type StaticDimension v = 'Nothing
Instances
class (DimensionAware v, StaticDimension v ~ 'Just n) => Dimensional n v | v -> n where Source #
knownDimensionalitySing :: Sing n Source #
default knownDimensionalitySing :: KnownNat n => Sing n Source #
unsafeFromArrayWithOffset :: Vector α (Scalar v) => Int -> α (Scalar v) -> v Source #
Read basis expansion from an array, starting at the specified offset.
The array must have at least length n + offset
, else the behaviour is undefined.
unsafeWriteArrayWithOffset :: Vector α (Scalar v) => Mutable α σ (Scalar v) -> Int -> v -> ST σ () Source #
Instances
data DimensionalityCases v where Source #
Batteries-included version of DimensionalityWitness
.
StaticDimensionalCase :: (KnownNat n, n `Dimensional` v) => DimensionalityCases v | |
FlexibleDimensionalCase :: StaticDimension v ~ 'Nothing => DimensionalityCases v |
type Dimension v = FromJust (StaticDimension v) Source #
class DimensionAware v => StaticDimensional v where Source #
dimensionIsStatic :: forall r. (forall n. (KnownNat n, n `Dimensional` v) => r) -> r Source #
Instances
(DimensionAware v, IsJust (StaticDimension v) ~ 'True) => StaticDimensional v Source # | |
Defined in Math.VectorSpace.DimensionAware dimensionIsStatic :: (forall (n :: Nat). (KnownNat n, Dimensional n v) => r) -> r Source # |
dimensionalitySing :: forall v n. n `Dimensional` v => Sing n Source #
dimensionality :: forall v. DimensionAware v => DimensionalityCases v Source #
dimension :: forall v n a. (n `Dimensional` v, Integral a) => a Source #
dimensionOf :: forall v n a. (n `Dimensional` v, Integral a) => v -> a Source #
Convenience function. The result does never depend on the runtime input, only on its type.
unsafeFromArray :: forall v n α. (n `Dimensional` v, Vector α (Scalar v)) => α (Scalar v) -> v Source #
Read basis expansion from an array. The array must have length n
, else the
behaviour is undefined.
fromArray :: forall v n α. (n `Dimensional` v, Vector α (Scalar v)) => α (Scalar v) -> Maybe v Source #
Read basis expansion from an array, if the size equals the dimension.
toArray :: forall v n α. (n `Dimensional` v, Vector α (Scalar v)) => v -> α (Scalar v) Source #
Write out basis expansion to an array, whose length will always be n
.
staticDimensionSing :: forall v. DimensionAware v => Sing (StaticDimension v) Source #
scalarUnsafeWriteArrayWithOffset :: (v ~ Scalar v, Vector α v) => Mutable α σ v -> Int -> v -> ST σ () Source #
unsafeFromArrayWithOffsetViaList :: forall v n α. (n `Dimensional` v, Vector α (Scalar v)) => ([Scalar v] -> v) -> Int -> α (Scalar v) -> v Source #
unsafeWriteArrayWithOffsetViaList :: forall v n α σ. (n `Dimensional` v, Vector α (Scalar v)) => (v -> [Scalar v]) -> Mutable α σ (Scalar v) -> Int -> v -> ST σ () Source #
notStaticDimensionalContradiction :: forall v n r. StaticDimension v ~ 'Nothing => r Source #
To be used as an “absurd” values for implementing methods whose constraints combine to require both static- and flexible dimensionality (which can thus never be called).
The actual type of this should be
notStaticDimensionalContradiction :: ∀ v n r
. (nDimensional
v, StaticDimension v ~ 'Nothing) => r
GHC 9.6 baulks at that, though. It is a self-contradicting type, but that's the whole point...