Numeric.DataFrame.SubSpace

Documentation

class (ConcatList as bs asbs, Dimensions as, Dimensions bs, Dimensions asbs, PrimArray t (DataFrame t asbs)) => SubSpace (t :: Type) (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) | asbs as -> bs, asbs bs -> as, as bs -> asbs where

Operations on DataFrames

as is an element dimensionality

bs is an indexing dimensionality

t is an underlying data type (i.e. Float, Int, Double)

Methods

indexOffset#

Arguments

:: Int#

Prim element offset

-> Int#

Number of prim elements in the prefix subspace

-> DataFrame t asbs

-> DataFrame t as

Unsafely get a sub-dataframe by its primitive element offset. 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

update :: Idxs bs -> DataFrame t as -> DataFrame t asbs -> DataFrame t asbs

Set a new value to an element

ewmap :: forall s (as' :: [Nat]) (asbs' :: [Nat]). SubSpace s as' bs asbs' => (DataFrame s as' -> DataFrame t as) -> DataFrame s asbs' -> DataFrame t asbs

Map a function over each element of DataFrame

iwmap :: forall s (as' :: [Nat]) (asbs' :: [Nat]). SubSpace s as' bs asbs' => (Idxs bs -> DataFrame s as' -> DataFrame t as) -> DataFrame s asbs' -> DataFrame t asbs

Map a function over each element with its index of DataFrame

ewgen :: DataFrame t as -> DataFrame t asbs

Generate a DataFrame by repeating an element

iwgen :: (Idxs bs -> DataFrame t as) -> DataFrame t asbs

Generate a DataFrame by iterating a function (index -> element)

ewfoldl :: (b -> DataFrame t as -> b) -> b -> DataFrame t asbs -> b

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 :: (Idxs bs -> b -> DataFrame t as -> b) -> b -> DataFrame t asbs -> b

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

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 :: (Idxs bs -> DataFrame t as -> b -> b) -> b -> DataFrame t asbs -> b

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' :: [Nat]) (asbs' :: [Nat]) f. (Applicative f, SubSpace s as' bs asbs') => (DataFrame s as' -> f (DataFrame t as)) -> DataFrame s asbs' -> f (DataFrame t asbs)

Apply an applicative functor on each element (Lens-like traversal)

indexWise :: forall s (as' :: [Nat]) (asbs' :: [Nat]) f. (Applicative f, SubSpace s as' bs asbs') => (Idxs bs -> DataFrame s as' -> f (DataFrame t as)) -> DataFrame s asbs' -> f (DataFrame t asbs)

Apply an applicative functor on each element with its index (Lens-like indexed traversal)

Instances

(ConcatList as bs asbs, Dimensions as, Dimensions bs, Dimensions asbs, PrimArray t (DataFrame t as), PrimArray t (DataFrame t asbs), PrimBytes (DataFrame t as), PrimBytes (DataFrame t asbs)) => SubSpace t as bs asbs

Defined in Numeric.DataFrame.SubSpace

Methods

indexOffset# :: Int# -> Int# -> DataFrame t asbs -> DataFrame t as

update :: Idxs bs -> DataFrame t as -> DataFrame t asbs -> DataFrame t asbs

ewmap :: SubSpace s as' bs asbs' => (DataFrame s as' -> DataFrame t as) -> DataFrame s asbs' -> DataFrame t asbs

iwmap :: SubSpace s as' bs asbs' => (Idxs bs -> DataFrame s as' -> DataFrame t as) -> DataFrame s asbs' -> DataFrame t asbs

ewgen :: DataFrame t as -> DataFrame t asbs

iwgen :: (Idxs bs -> DataFrame t as) -> DataFrame t asbs

ewfoldl :: (b -> DataFrame t as -> b) -> b -> DataFrame t asbs -> b

iwfoldl :: (Idxs bs -> b -> DataFrame t as -> b) -> b -> DataFrame t asbs -> b

ewfoldr :: (DataFrame t as -> b -> b) -> b -> DataFrame t asbs -> b

iwfoldr :: (Idxs bs -> DataFrame t as -> b -> b) -> b -> DataFrame t asbs -> b

elementWise :: (Applicative f, SubSpace s as' bs asbs') => (DataFrame s as' -> f (DataFrame t as)) -> DataFrame s asbs' -> f (DataFrame t asbs)

indexWise :: (Applicative f, SubSpace s as' bs asbs') => (Idxs bs -> DataFrame s as' -> f (DataFrame t as)) -> DataFrame s asbs' -> f (DataFrame t asbs)

(!) :: SubSpace t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) => DataFrame t asbs -> Idxs bs -> DataFrame t as infixl 4

Index an element (reverse of !.)

(!.) :: forall t as bs asbs. SubSpace t as bs asbs => Idxs bs -> DataFrame t asbs -> DataFrame t as infixr 4

Get an element by its index in the dataframe

element :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) f. (SubSpace t as bs asbs, Applicative f) => Idxs bs -> (DataFrame t as -> f (DataFrame t as)) -> DataFrame t asbs -> f (DataFrame t asbs)

Apply a functor over a single element (simple lens)

ewfoldMap :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) m. (Monoid m, SubSpace t as bs asbs) => (DataFrame t as -> m) -> DataFrame t asbs -> m

iwfoldMap :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) m. (Monoid m, SubSpace t as bs asbs) => (Idxs bs -> DataFrame t as -> m) -> DataFrame t asbs -> m

ewzip :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) s (as' :: [Nat]) (asbs' :: [Nat]) r (as'' :: [Nat]) (asbs'' :: [Nat]). (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''

Zip two spaces on a specified subspace element-wise (without index)

iwzip :: forall t (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) s (as' :: [Nat]) (asbs' :: [Nat]) r (as'' :: [Nat]) (asbs'' :: [Nat]). (SubSpace t as bs asbs, SubSpace s as' bs asbs', SubSpace r as'' bs asbs'') => (Idxs bs -> DataFrame t as -> DataFrame s as' -> DataFrame r as'') -> DataFrame t asbs -> DataFrame s asbs' -> DataFrame r asbs''

Zip two spaces on a specified subspace index-wise (with index)

indexWise_ :: forall t as bs asbs f b. (SubSpace t as bs asbs, Applicative f) => (Idxs bs -> DataFrame t as -> f b) -> DataFrame t asbs -> f ()

Apply an applicative functor on each element with its index (Lens-like indexed traversal)

elementWise_ :: forall t as bs asbs f b. (SubSpace t as bs asbs, Applicative f) => (DataFrame t as -> f b) -> DataFrame t asbs -> f ()

Apply an applicative functor on each element (Lens-like traversal)