Copyright | (c) Artem Chirkin |
---|---|
License | BSD3 |
Maintainer | chirkin@arch.ethz.ch |
Safe Haskell | None |
Language | Haskell2010 |
- data family DataFrame (t :: Type) (xs :: [k])
- type NumericFrame t ds = (CommonOpFrame t ds, NumericVariantFrame t ds)
- type FPFRame t ds = (Fractional (DataFrame t ds), Floating (DataFrame t ds))
- type IntegralFrame t ds = Bounded (DataFrame t ds)
- type family NumericVariantFrame t ds :: Constraint where ...
- type CommonOpFrame t ds = (Show (DataFrame t ds), Eq (DataFrame t ds), Ord (DataFrame t ds), Num (DataFrame t ds), ElementWise (Idx ds) t (DataFrame t ds), PrimBytes (DataFrame t ds), ArrayInstanceInference t ds, KnownDims ds, FiniteList ds, Dimensions ds)
- module Numeric.Scalar
- module Numeric.Vector
- module Numeric.Matrix
- class (ConcatList as bs asbs, Dimensions as, Dimensions bs, Dimensions asbs) => SubSpace t as bs asbs | asbs as -> bs, asbs bs -> as, as bs -> asbs where
- (!) :: SubSpace t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) => DataFrame t asbs -> Idx bs -> DataFrame t as
- element :: forall t as bs asbs f. (SubSpace t as bs asbs, Applicative f) => Idx bs -> (DataFrame t as -> f (DataFrame t as)) -> DataFrame t asbs -> f (DataFrame t asbs)
- ewfoldMap :: forall t as bs asbs m. (Monoid m, SubSpace t as bs asbs) => (DataFrame t as -> m) -> DataFrame t asbs -> m
- iwfoldMap :: forall t as bs asbs m. (Monoid m, SubSpace t as bs asbs) => (Idx bs -> DataFrame t as -> m) -> DataFrame t asbs -> m
- ewzip :: forall t as bs asbs s as' asbs' r as'' asbs''. (SubSpace t as bs asbs, SubSpace s as' bs asbs', SubSpace r as'' bs asbs'') => (DataFrame t as -> DataFrame s as' -> DataFrame r as'') -> DataFrame t asbs -> DataFrame s asbs' -> DataFrame r asbs''
- iwzip :: forall t as bs asbs s as' asbs' r as'' asbs''. (SubSpace t as bs asbs, SubSpace s as' bs asbs', SubSpace r as'' bs asbs'') => (Idx bs -> DataFrame t as -> DataFrame s as' -> DataFrame r as'') -> DataFrame t asbs -> DataFrame s asbs' -> DataFrame r asbs''
- class ConcatList as bs asbs => Contraction t as bs asbs | asbs as -> bs, asbs bs -> as, as bs -> asbs where
- (%*) :: (ConcatList as bs (as ++ bs), Contraction t as bs asbs, KnownDim m, PrimBytes (DataFrame t (as +: m)), PrimBytes (DataFrame t (m :+ bs)), PrimBytes (DataFrame t (as ++ bs))) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t (as ++ bs)
- type PrimBytesEvidence t ds = Evidence (PrimBytes (DataFrame t ds))
- inferPrimBytes :: forall t ds. (ArrayInstanceInference t ds, Dimensions ds) => PrimBytesEvidence t ds
- type ElementWiseEvidence t ds = Evidence (ElementWise (Idx ds) t (DataFrame t ds))
- inferElementWise :: forall t ds. (ArrayInstanceInference t ds, Dimensions ds) => ElementWiseEvidence t ds
- type NumericFrameEvidence t ds = Evidence (NumericFrame t ds)
- inferNumericFrame :: forall t ds. (ArrayInstanceInference t ds, Dimensions ds) => NumericFrameEvidence t ds
- (<:>) :: forall n m npm ds t. (PrimBytes (DataFrame t (ds +: n)), PrimBytes (DataFrame t (ds +: m)), PrimBytes (DataFrame t (ds +: npm)), npm ~ (n + m), n ~ (npm - m), m ~ (npm - n)) => DataFrame t (ds +: n) -> DataFrame t (ds +: m) -> DataFrame t (ds +: npm)
- (<::>) :: forall ds t. (PrimBytes (DataFrame t ds), PrimBytes (DataFrame t ds), PrimBytes (DataFrame t (ds +: 2 :: [Nat]))) => DataFrame t ds -> DataFrame t ds -> DataFrame t (ds +: 2 :: [Nat])
- (<+:>) :: forall ds n m t. (PrimBytes (DataFrame t (ds +: n)), PrimBytes (DataFrame t ds), PrimBytes (DataFrame t (ds +: m)), m ~ (n + 1)) => DataFrame t (ds +: n) -> DataFrame t ds -> DataFrame t (ds +: m)
- fromList :: forall ns t xns xnsm. (ns ~ AsDims xns, xnsm ~ (xns +: XN 2), PrimBytes (DataFrame t ns), Dimensions ns, ArrayInstanceInference t ns) => [DataFrame t ns] -> DataFrame t (xns +: XN 2)
- class DataFrameToList t z ds where
- fromScalar :: ElementWise (Idx ds) t (DataFrame t ds) => Scalar t -> DataFrame t ds
- class ElementWise i x t | t -> x i
- type ArrayInstanceEvidence t ds = Evidence (ArrayInstanceInference t ds)
- data ArrayInstance t ds
- = (Array t ds ~ Scalar t, ds ~ '[]) => AIScalar
- | (Array t ds ~ ArrayF ds, ds ~ (n ': ns), t ~ Float) => AIArrayF
- | (Array t ds ~ ArrayD ds, ds ~ (n ': ns), t ~ Double) => AIArrayD
- | (Array t ds ~ ArrayI ds, ds ~ (n ': ns), t ~ Int) => AIArrayI
- | (Array t ds ~ ArrayI8 ds, ds ~ (n ': ns), t ~ Int8) => AIArrayI8
- | (Array t ds ~ ArrayI16 ds, ds ~ (n ': ns), t ~ Int16) => AIArrayI16
- | (Array t ds ~ ArrayI32 ds, ds ~ (n ': ns), t ~ Int32) => AIArrayI32
- | (Array t ds ~ ArrayI64 ds, ds ~ (n ': ns), t ~ Int64) => AIArrayI64
- | (Array t ds ~ ArrayW ds, ds ~ (n ': ns), t ~ Word) => AIArrayW
- | (Array t ds ~ ArrayW8 ds, ds ~ (n ': ns), t ~ Word8) => AIArrayW8
- | (Array t ds ~ ArrayW16 ds, ds ~ (n ': ns), t ~ Word16) => AIArrayW16
- | (Array t ds ~ ArrayW32 ds, ds ~ (n ': ns), t ~ Word32) => AIArrayW32
- | (Array t ds ~ ArrayW64 ds, ds ~ (n ': ns), t ~ Word64) => AIArrayW64
- | (Array t ds ~ FloatX2, ds ~ '[2], t ~ Float) => AIFloatX2
- | (Array t ds ~ FloatX3, ds ~ '[3], t ~ Float) => AIFloatX3
- | (Array t ds ~ FloatX4, ds ~ '[4], t ~ Float) => AIFloatX4
- | (Array t ds ~ DoubleX2, ds ~ '[2], t ~ Double) => AIDoubleX2
- | (Array t ds ~ DoubleX3, ds ~ '[3], t ~ Double) => AIDoubleX3
- | (Array t ds ~ DoubleX4, ds ~ '[4], t ~ Double) => AIDoubleX4
- getArrayInstance :: forall t ds. ArrayInstanceInference t ds => ArrayInstance t ds
- inferArrayInstance :: forall t ds. (FiniteList ds, KnownDims ds, ElemTypeInference t) => ArrayInstanceEvidence t ds
- class ArraySizeInference ds where
- data ArraySize ds
- class ElemTypeInference t where
- data ElemType t
Documentation
data family DataFrame (t :: Type) (xs :: [k]) Source #
Keep data in a primitive data frame and maintain information about Dimensions in the type-system
type NumericFrame t ds = (CommonOpFrame t ds, NumericVariantFrame t ds) Source #
Allow all numeric operations depending on element type
Utility type families and constraints
type FPFRame t ds = (Fractional (DataFrame t ds), Floating (DataFrame t ds)) Source #
Allow floating-point operations on data frames
type IntegralFrame t ds = Bounded (DataFrame t ds) Source #
Allow some integer-like operations on data frames
type family NumericVariantFrame t ds :: Constraint where ... Source #
NumericVariantFrame Float ds = FPFRame Float ds | |
NumericVariantFrame Double ds = FPFRame Double ds | |
NumericVariantFrame Int ds = IntegralFrame Int ds | |
NumericVariantFrame Int8 ds = IntegralFrame Int8 ds | |
NumericVariantFrame Int16 ds = IntegralFrame Int16 ds | |
NumericVariantFrame Int32 ds = IntegralFrame Int32 ds | |
NumericVariantFrame Int64 ds = IntegralFrame Int64 ds | |
NumericVariantFrame Word ds = IntegralFrame Word ds | |
NumericVariantFrame Word8 ds = IntegralFrame Word8 ds | |
NumericVariantFrame Word16 ds = IntegralFrame Word16 ds | |
NumericVariantFrame Word32 ds = IntegralFrame Word32 ds | |
NumericVariantFrame Word64 ds = IntegralFrame Word64 ds | |
NumericVariantFrame _ _ = () |
type CommonOpFrame t ds = (Show (DataFrame t ds), Eq (DataFrame t ds), Ord (DataFrame t ds), Num (DataFrame t ds), ElementWise (Idx ds) t (DataFrame t ds), PrimBytes (DataFrame t ds), ArrayInstanceInference t ds, KnownDims ds, FiniteList ds, Dimensions ds) Source #
Allow all common operations on data frames
Simplified type aliases
module Numeric.Scalar
module Numeric.Vector
module Numeric.Matrix
Functionality
class (ConcatList as bs asbs, Dimensions as, Dimensions bs, Dimensions asbs) => SubSpace t as bs asbs | asbs as -> bs, asbs bs -> as, as bs -> asbs where Source #
Operations on DataFrames
as
is an element dimensionality
bs
is an indexing dimensionality
t
is an underlying data type (i.e. Float, Int, Double)
indexOffset#, update, ewmap, iwmap, ewgen, iwgen, ewfoldl, iwfoldl, ewfoldr, iwfoldr, elementWise, indexWise
indexOffset# :: Int# -> Int# -> DataFrame t asbs -> DataFrame t as Source #
Unsafely get a sub-dataframe by its primitive element subset.
The offset is not checked to be aligned to the space structure or for bounds.
Arguments are zero-based primitive element offset and subset ("as" element) size (aka totalDim
of sub dataframe)
Normal indexing can be expressed in terms of indexOffset#
:
i !. x = case (# dimVal (dim @as), fromEnum i #) of (# I# n, I# j #) -> indexOffset# (n *# j) n x
(!.) :: Idx bs -> DataFrame t asbs -> DataFrame t as infixr 4 Source #
Get an element by its index in the dataframe
update :: Idx bs -> DataFrame t as -> DataFrame t asbs -> DataFrame t asbs Source #
Set a new value to an element
ewmap :: forall s as' asbs'. SubSpace s as' bs asbs' => (DataFrame s as' -> DataFrame t as) -> DataFrame s asbs' -> DataFrame t asbs Source #
Map a function over each element of DataFrame
iwmap :: forall s as' asbs'. SubSpace s as' bs asbs' => (Idx bs -> DataFrame s as' -> DataFrame t as) -> DataFrame s asbs' -> DataFrame t asbs Source #
Map a function over each element with its index of DataFrame
ewgen :: DataFrame t as -> DataFrame t asbs Source #
Generate a DataFrame by repeating an element
iwgen :: (Idx bs -> DataFrame t as) -> DataFrame t asbs Source #
Generate a DataFrame by iterating a function (index -> element)
ewfoldl :: (b -> DataFrame t as -> b) -> b -> DataFrame t asbs -> b Source #
Left-associative fold of a DataFrame. The fold is strict, so accumulater is evaluated to WHNF; but you'd better make sure that the function is strict enough to not produce memory leaks deeply inside the result data type.
iwfoldl :: (Idx bs -> b -> DataFrame t as -> b) -> b -> DataFrame t asbs -> b Source #
Left-associative fold of a DataFrame with an index The fold is strict, so accumulater is evaluated to WHNF; but you'd better make sure that the function is strict enough to not produce memory leaks deeply inside the result data type.
ewfoldr :: (DataFrame t as -> b -> b) -> b -> DataFrame t asbs -> b Source #
Right-associative fold of a DataFrame The fold is strict, so accumulater is evaluated to WHNF; but you'd better make sure that the function is strict enough to not produce memory leaks deeply inside the result data type.
iwfoldr :: (Idx bs -> DataFrame t as -> b -> b) -> b -> DataFrame t asbs -> b Source #
Right-associative fold of a DataFrame with an index The fold is strict, so accumulater is evaluated to WHNF; but you'd better make sure that the function is strict enough to not produce memory leaks deeply inside the result data type.
elementWise :: forall s as' asbs' f. (Applicative f, SubSpace s as' bs asbs') => (DataFrame s as' -> f (DataFrame t as)) -> DataFrame s asbs' -> f (DataFrame t asbs) Source #
Apply an applicative functor on each element (Lens-like traversal)
indexWise :: forall s as' asbs' f. (Applicative f, SubSpace s as' bs asbs') => (Idx bs -> DataFrame s as' -> f (DataFrame t as)) -> DataFrame s asbs' -> f (DataFrame t asbs) Source #
Apply an applicative functor on each element with its index (Lens-like indexed traversal)
(ConcatList Nat as bs asbs, Dimensions as, Dimensions bs, Dimensions asbs, PrimBytes (DataFrame Nat t as), PrimBytes (DataFrame Nat t asbs), (~) [Nat] as ((:) Nat a'' as''), (~) [Nat] asbs ((:) Nat a'' asbs'')) => SubSpace t as bs asbs Source # | |
(Dimensions bs, ElementWise (Idx bs) t (DataFrame Nat t bs), PrimBytes (DataFrame Nat t bs)) => SubSpace t ([] Nat) bs bs Source # | Specialized instance of SubSpace for operating on scalars. |
(!) :: SubSpace t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) => DataFrame t asbs -> Idx bs -> DataFrame t as infixl 4 Source #
Index an element (reverse of !.)
element :: forall t as bs asbs f. (SubSpace t as bs asbs, Applicative f) => Idx bs -> (DataFrame t as -> f (DataFrame t as)) -> DataFrame t asbs -> f (DataFrame t asbs) Source #
Apply a functor over a single element (simple lens)
ewfoldMap :: forall t as bs asbs m. (Monoid m, SubSpace t as bs asbs) => (DataFrame t as -> m) -> DataFrame t asbs -> m Source #
iwfoldMap :: forall t as bs asbs m. (Monoid m, SubSpace t as bs asbs) => (Idx bs -> DataFrame t as -> m) -> DataFrame t asbs -> m Source #
ewzip :: forall t as bs asbs s as' asbs' r as'' asbs''. (SubSpace t as bs asbs, SubSpace s as' bs asbs', SubSpace r as'' bs asbs'') => (DataFrame t as -> DataFrame s as' -> DataFrame r as'') -> DataFrame t asbs -> DataFrame s asbs' -> DataFrame r asbs'' Source #
Zip two spaces on a specified subspace element-wise (without index)
iwzip :: forall t as bs asbs s as' asbs' r as'' asbs''. (SubSpace t as bs asbs, SubSpace s as' bs asbs', SubSpace r as'' bs asbs'') => (Idx bs -> DataFrame t as -> DataFrame s as' -> DataFrame r as'') -> DataFrame t asbs -> DataFrame s asbs' -> DataFrame r asbs'' Source #
Zip two spaces on a specified subspace index-wise (with index)
class ConcatList as bs asbs => Contraction t as bs asbs | asbs as -> bs, asbs bs -> as, as bs -> asbs where Source #
contract :: (KnownDim m, PrimBytes (DataFrame t (as +: m)), PrimBytes (DataFrame t (m :+ bs)), PrimBytes (DataFrame t asbs)) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t asbs Source #
Generalization of a matrix product: take scalar product over one dimension and, thus, concatenate other dimesnions
(%*) :: (ConcatList as bs (as ++ bs), Contraction t as bs asbs, KnownDim m, PrimBytes (DataFrame t (as +: m)), PrimBytes (DataFrame t (m :+ bs)), PrimBytes (DataFrame t (as ++ bs))) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t (as ++ bs) infixl 7 Source #
Tensor contraction. In particular: 1. matrix-matrix product 2. matrix-vector or vector-matrix product 3. dot product of two vectors.
type PrimBytesEvidence t ds = Evidence (PrimBytes (DataFrame t ds)) Source #
Evidence for PrimBytes class
inferPrimBytes :: forall t ds. (ArrayInstanceInference t ds, Dimensions ds) => PrimBytesEvidence t ds Source #
type ElementWiseEvidence t ds = Evidence (ElementWise (Idx ds) t (DataFrame t ds)) Source #
Evidence for ElementWise class
inferElementWise :: forall t ds. (ArrayInstanceInference t ds, Dimensions ds) => ElementWiseEvidence t ds Source #
type NumericFrameEvidence t ds = Evidence (NumericFrame t ds) Source #
Allow all common operations on available data frames
inferNumericFrame :: forall t ds. (ArrayInstanceInference t ds, Dimensions ds) => NumericFrameEvidence t ds Source #
(<:>) :: forall n m npm ds t. (PrimBytes (DataFrame t (ds +: n)), PrimBytes (DataFrame t (ds +: m)), PrimBytes (DataFrame t (ds +: npm)), npm ~ (n + m), n ~ (npm - m), m ~ (npm - n)) => DataFrame t (ds +: n) -> DataFrame t (ds +: m) -> DataFrame t (ds +: npm) infixl 5 Source #
Append one DataFrame to another, adding up their last dimensionality
(<::>) :: forall ds t. (PrimBytes (DataFrame t ds), PrimBytes (DataFrame t ds), PrimBytes (DataFrame t (ds +: 2 :: [Nat]))) => DataFrame t ds -> DataFrame t ds -> DataFrame t (ds +: 2 :: [Nat]) infixl 5 Source #
Append one DataFrame to another, adding up their last dimensionality
(<+:>) :: forall ds n m t. (PrimBytes (DataFrame t (ds +: n)), PrimBytes (DataFrame t ds), PrimBytes (DataFrame t (ds +: m)), m ~ (n + 1)) => DataFrame t (ds +: n) -> DataFrame t ds -> DataFrame t (ds +: m) infixl 5 Source #
Append one DataFrame to another, adding up their last dimensionality
fromList :: forall ns t xns xnsm. (ns ~ AsDims xns, xnsm ~ (xns +: XN 2), PrimBytes (DataFrame t ns), Dimensions ns, ArrayInstanceInference t ns) => [DataFrame t ns] -> DataFrame t (xns +: XN 2) Source #
Input must be parametrized by [Nat] to make sure every element in the input list has the same dimensionality. Output is in [XNat], because the last dimension is unknown at compile time
class DataFrameToList t z ds where Source #
Implement function toList
.
We need to create a dedicated type class for this
to make it polymorphic over kind k (Nat - XNat).
toList :: DataFrame t (ds +: z) -> [DataFrame t ds] Source #
Unwrap the last dimension of a DataFrame into a list of smaller frames
(Dimensions ns, Dimensions ((+:) Nat ns z), PrimBytes (DataFrame Nat t ns), PrimBytes (DataFrame Nat t ((+:) Nat ns z))) => DataFrameToList Nat t z ns Source # | |
DataFrameToList XNat t xz xns Source # | |
fromScalar :: ElementWise (Idx ds) t (DataFrame t ds) => Scalar t -> DataFrame t ds Source #
Broadcast scalar value onto a whole data frame
class ElementWise i x t | t -> x i Source #
Access elements. i is an index type x is an element t is a container type
indexOffset#, (!), ewmap, ewgen, ewgenA, ewfoldl, ewfoldr, elementWise, indexWise, broadcast, update
ElementWise Int Double Double Source # | |
ElementWise Int Float Float Source # | |
ElementWise Int Int Int Source # | |
ElementWise Int Int8 Int8 Source # | |
ElementWise Int Int16 Int16 Source # | |
ElementWise Int Int32 Int32 Source # | |
ElementWise Int Int64 Int64 Source # | |
ElementWise Int Word Word Source # | |
ElementWise Int Word8 Word8 Source # | |
ElementWise Int Word16 Word16 Source # | |
ElementWise Int Word32 Word32 Source # | |
ElementWise Int Word64 Word64 Source # | |
(Dimensions ds, ElementWise (Idx ds) t (Array t ds)) => ElementWise (Idx ds) t (DataFrame Nat t ds) Source # | |
type ArrayInstanceEvidence t ds = Evidence (ArrayInstanceInference t ds) Source #
A singleton type used to prove that the given Array family instance has a known instance
data ArrayInstance t ds Source #
Keep information about the instance behind Array family
Warning! This part of the code is platform and flag dependent.
(Array t ds ~ Scalar t, ds ~ '[]) => AIScalar | |
(Array t ds ~ ArrayF ds, ds ~ (n ': ns), t ~ Float) => AIArrayF | |
(Array t ds ~ ArrayD ds, ds ~ (n ': ns), t ~ Double) => AIArrayD | |
(Array t ds ~ ArrayI ds, ds ~ (n ': ns), t ~ Int) => AIArrayI | |
(Array t ds ~ ArrayI8 ds, ds ~ (n ': ns), t ~ Int8) => AIArrayI8 | |
(Array t ds ~ ArrayI16 ds, ds ~ (n ': ns), t ~ Int16) => AIArrayI16 | |
(Array t ds ~ ArrayI32 ds, ds ~ (n ': ns), t ~ Int32) => AIArrayI32 | |
(Array t ds ~ ArrayI64 ds, ds ~ (n ': ns), t ~ Int64) => AIArrayI64 | |
(Array t ds ~ ArrayW ds, ds ~ (n ': ns), t ~ Word) => AIArrayW | |
(Array t ds ~ ArrayW8 ds, ds ~ (n ': ns), t ~ Word8) => AIArrayW8 | |
(Array t ds ~ ArrayW16 ds, ds ~ (n ': ns), t ~ Word16) => AIArrayW16 | |
(Array t ds ~ ArrayW32 ds, ds ~ (n ': ns), t ~ Word32) => AIArrayW32 | |
(Array t ds ~ ArrayW64 ds, ds ~ (n ': ns), t ~ Word64) => AIArrayW64 | |
(Array t ds ~ FloatX2, ds ~ '[2], t ~ Float) => AIFloatX2 | |
(Array t ds ~ FloatX3, ds ~ '[3], t ~ Float) => AIFloatX3 | |
(Array t ds ~ FloatX4, ds ~ '[4], t ~ Float) => AIFloatX4 | |
(Array t ds ~ DoubleX2, ds ~ '[2], t ~ Double) => AIDoubleX2 | |
(Array t ds ~ DoubleX3, ds ~ '[3], t ~ Double) => AIDoubleX3 | |
(Array t ds ~ DoubleX4, ds ~ '[4], t ~ Double) => AIDoubleX4 |
getArrayInstance :: forall t ds. ArrayInstanceInference t ds => ArrayInstance t ds Source #
inferArrayInstance :: forall t ds. (FiniteList ds, KnownDims ds, ElemTypeInference t) => ArrayInstanceEvidence t ds Source #
Given element type instance and proper dimension list, infer a corresponding array instance
class ArraySizeInference ds where Source #
arraySizeInstance :: ArraySize ds Source #
Pattern match agains result to get actual array dimensionality
inferSnocArrayInstance :: (ElemTypeInference t, KnownDim z) => p t ds -> q z -> ArrayInstanceEvidence t (ds +: z) Source #
inferConsArrayInstance :: (ElemTypeInference t, KnownDim z) => q z -> p t ds -> ArrayInstanceEvidence t (z :+ ds) Source #
inferInitArrayInstance :: ElemTypeInference t => p t ds -> ArrayInstanceEvidence t (Init ds) Source #
Keep information about the array dimensionality
Warning! This part of the code is platform and flag dependent.
class ElemTypeInference t where Source #
elemTypeInstance :: ElemType t Source #
Pattern match against result to get specific element type
Keep information about the element type instance.
Warning! This part of the code is platform and flag dependent.