Data.Repa.Scalar.Product

Product type

data a :*: b infixr 9

A strict product type, written infix.

Constructors

!a :*: !b infixr 9

Instances

(Unbox a, Unbox b) => Vector Vector ((:*:) a b)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a :*: b) -> m (Vector (a :*: b))

basicUnsafeThaw :: PrimMonad m => Vector (a :*: b) -> m (Mutable Vector (PrimState m) (a :*: b))

basicLength :: Vector (a :*: b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a :*: b) -> Vector (a :*: b)

basicUnsafeIndexM :: Monad m => Vector (a :*: b) -> Int -> m (a :*: b)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a :*: b) -> Vector (a :*: b) -> m ()

elemseq :: Vector (a :*: b) -> (a :*: b) -> b -> b

(Unbox a, Unbox b) => MVector MVector ((:*:) a b)

Methods

basicLength :: MVector s (a :*: b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a :*: b) -> MVector s (a :*: b)

basicOverlaps :: MVector s (a :*: b) -> MVector s (a :*: b) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a :*: b))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a :*: b) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a :*: b) -> m (MVector (PrimState m) (a :*: b))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a :*: b) -> Int -> m (a :*: b)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a :*: b) -> Int -> (a :*: b) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a :*: b) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a :*: b) -> (a :*: b) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a :*: b) -> MVector (PrimState m) (a :*: b) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a :*: b) -> MVector (PrimState m) (a :*: b) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a :*: b) -> Int -> m (MVector (PrimState m) (a :*: b))

IsProdList ts => Discard Z ((:*:) t1 ts)

Associated Types

type Discard' (Z :: N) ((:*:) t1 ts) :: *

Methods

discard :: Nat Z -> (t1 :*: ts) -> Discard' Z (t1 :*: ts)

IsProdList ts => Select Z ((:*:) t1 ts)

Associated Types

type Select' (Z :: N) ((:*:) t1 ts) :: *

Methods

select :: Nat Z -> (t1 :*: ts) -> Select' Z (t1 :*: ts)

Functor ((:*:) a)

Methods

fmap :: (a -> b) -> (a :*: a) -> a :*: b

(<$) :: a -> (a :*: b) -> a :*: a

Discard n ts => Discard (S n) ((:*:) t1 ts)

Associated Types

type Discard' (S n :: N) ((:*:) t1 ts) :: *

Methods

discard :: Nat (S n) -> (t1 :*: ts) -> Discard' (S n) (t1 :*: ts)

Select n ts => Select (S n) ((:*:) t1 ts)

Associated Types

type Select' (S n :: N) ((:*:) t1 ts) :: *

Methods

select :: Nat (S n) -> (t1 :*: ts) -> Select' (S n) (t1 :*: ts)

(Eq b, Eq a) => Eq ((:*:) a b)

Methods

(==) :: (a :*: b) -> (a :*: b) -> Bool

(/=) :: (a :*: b) -> (a :*: b) -> Bool

(Show b, Show a) => Show ((:*:) a b)

Methods

showsPrec :: Int -> (a :*: b) -> ShowS

show :: (a :*: b) -> String

showList :: [a :*: b] -> ShowS

(Unbox a, Unbox b) => Unbox ((:*:) a b)

(IsKeyValues p, IsKeyValues ps, (~) * (Keys p) (Keys ps)) => IsKeyValues ((:*:) p ps)

Associated Types

type Keys ((:*:) p ps) :: *

type Values ((:*:) p ps) :: *

Methods

keys :: (p :*: ps) -> [Keys (p :*: ps)]

values :: (p :*: ps) -> Values (p :*: ps)

IsProdList fs => IsProdList ((:*:) f fs)

Methods

isProdList :: (f :*: fs) -> Bool

Mask ms ts => Mask ((:*:) Keep ms) ((:*:) t1 ts)

Associated Types

type Mask' ((:*:) Keep ms) ((:*:) t1 ts) :: *

Methods

mask :: (Keep :*: ms) -> (t1 :*: ts) -> Mask' (Keep :*: ms) (t1 :*: ts)

Mask ms ts => Mask ((:*:) Drop ms) ((:*:) t1 ts)

Associated Types

type Mask' ((:*:) Drop ms) ((:*:) t1 ts) :: *

Methods

mask :: (Drop :*: ms) -> (t1 :*: ts) -> Mask' (Drop :*: ms) (t1 :*: ts)

data MVector s ((:*:) a b)

data MVector s ((:*:) a b) = MV_Prod !Int !(MVector s a) !(MVector s b)

type Discard' Z ((:*:) t1 ts)

type Discard' Z ((:*:) t1 ts) = ts

type Select' Z ((:*:) t1 ts)

type Select' Z ((:*:) t1 ts) = t1

type Discard' (S n) ((:*:) t1 ts)

type Discard' (S n) ((:*:) t1 ts) = (:*:) t1 (Discard' n ts)

type Select' (S n) ((:*:) t1 ts)

type Select' (S n) ((:*:) t1 ts) = Select' n ts

data Vector ((:*:) a b)

data Vector ((:*:) a b) = V_Prod !Int !(Vector a) !(Vector b)

type Keys ((:*:) p ps)

type Keys ((:*:) p ps) = Keys p

type Values ((:*:) p ps)

type Values ((:*:) p ps) = (:*:) (Values p) (Values ps)

type Mask' ((:*:) Keep ms) ((:*:) t1 ts)

type Mask' ((:*:) Keep ms) ((:*:) t1 ts) = (:*:) t1 (Mask' ms ts)

type Mask' ((:*:) Drop ms) ((:*:) t1 ts)

type Mask' ((:*:) Drop ms) ((:*:) t1 ts) = Mask' ms ts

class IsProdList p where

Sequences of products that form a valid list, using () for the nil value.

Minimal complete definition

isProdList

Methods

isProdList :: p -> Bool

Instances

IsProdList ()

Methods

isProdList :: () -> Bool

IsProdList fs => IsProdList ((:*:) f fs)

Methods

isProdList :: (f :*: fs) -> Bool

class IsKeyValues p where

Sequences of products and tuples that form hetrogeneous key-value pairs.

Minimal complete definition

keys, values

Associated Types

type Keys p

type Values p

Methods

keys :: p -> [Keys p]

Get a cons-list of all the keys.

values :: p -> Values p

Get a heterogeneous product-list of all the values.

Instances

IsKeyValues (k, v)

Associated Types

type Keys (k, v) :: *

type Values (k, v) :: *

Methods

keys :: (k, v) -> [Keys (k, v)]

values :: (k, v) -> Values (k, v)

(IsKeyValues p, IsKeyValues ps, (~) * (Keys p) (Keys ps)) => IsKeyValues ((:*:) p ps)

Associated Types

type Keys ((:*:) p ps) :: *

type Values ((:*:) p ps) :: *

Methods

keys :: (p :*: ps) -> [Keys (p :*: ps)]

values :: (p :*: ps) -> Values (p :*: ps)

Selecting

class IsProdList t => Select n t where

Minimal complete definition

select

Associated Types

type Select' n t

Methods

select :: Nat n -> t -> Select' n t

Return the element with this index from a product list.

Instances

IsProdList ts => Select Z ((:*:) t1 ts)

Associated Types

type Select' (Z :: N) ((:*:) t1 ts) :: *

Methods

select :: Nat Z -> (t1 :*: ts) -> Select' Z (t1 :*: ts)

Select n ts => Select (S n) ((:*:) t1 ts)

Associated Types

type Select' (S n :: N) ((:*:) t1 ts) :: *

Methods

select :: Nat (S n) -> (t1 :*: ts) -> Select' (S n) (t1 :*: ts)

Discarding

class IsProdList t => Discard n t where

Minimal complete definition

discard

Associated Types

type Discard' n t

Methods

discard :: Nat n -> t -> Discard' n t

Discard the element with this index from a product list.

Instances

IsProdList ts => Discard Z ((:*:) t1 ts)

Associated Types

type Discard' (Z :: N) ((:*:) t1 ts) :: *

Methods

discard :: Nat Z -> (t1 :*: ts) -> Discard' Z (t1 :*: ts)

Discard n ts => Discard (S n) ((:*:) t1 ts)

Associated Types

type Discard' (S n :: N) ((:*:) t1 ts) :: *

Methods

discard :: Nat (S n) -> (t1 :*: ts) -> Discard' (S n) (t1 :*: ts)

Masking

class (IsProdList m, IsProdList t) => Mask m t where

Class of data types that can have parts masked out.

Minimal complete definition

mask

Associated Types

type Mask' m t

Methods

mask :: m -> t -> Mask' m t

Mask out some component of a type.

mask (Keep :*: Drop  :*: Keep :*: ()) 
     (1    :*: "foo" :*: 'a'  :*: ())   =   (1 :*: 'a' :*: ())

mask (Drop :*: Drop  :*: Drop :*: ()) 
     (1    :*: "foo" :*: 'a'  :*: ())   =   ()

Instances

Mask () ()

Associated Types

type Mask' () () :: *

Methods

mask :: () -> () -> Mask' () ()

Mask ms ts => Mask ((:*:) Keep ms) ((:*:) t1 ts)

Associated Types

type Mask' ((:*:) Keep ms) ((:*:) t1 ts) :: *

Methods

mask :: (Keep :*: ms) -> (t1 :*: ts) -> Mask' (Keep :*: ms) (t1 :*: ts)

Mask ms ts => Mask ((:*:) Drop ms) ((:*:) t1 ts)

Associated Types

type Mask' ((:*:) Drop ms) ((:*:) t1 ts) :: *

Methods

mask :: (Drop :*: ms) -> (t1 :*: ts) -> Mask' (Drop :*: ms) (t1 :*: ts)

data Keep

Singleton to indicate a field that should be kept.

Constructors

Keep

Instances

Mask ms ts => Mask ((:*:) Keep ms) ((:*:) t1 ts)

Associated Types

type Mask' ((:*:) Keep ms) ((:*:) t1 ts) :: *

Methods

mask :: (Keep :*: ms) -> (t1 :*: ts) -> Mask' (Keep :*: ms) (t1 :*: ts)

type Mask' ((:*:) Keep ms) ((:*:) t1 ts)

type Mask' ((:*:) Keep ms) ((:*:) t1 ts) = (:*:) t1 (Mask' ms ts)

data Drop

Singleton to indicate a field that should be dropped.

Constructors

Drop

Instances

Mask ms ts => Mask ((:*:) Drop ms) ((:*:) t1 ts)

Associated Types

type Mask' ((:*:) Drop ms) ((:*:) t1 ts) :: *

Methods

mask :: (Drop :*: ms) -> (t1 :*: ts) -> Mask' (Drop :*: ms) (t1 :*: ts)

type Mask' ((:*:) Drop ms) ((:*:) t1 ts)

type Mask' ((:*:) Drop ms) ((:*:) t1 ts) = Mask' ms ts