Data.Massiv.Core.Index

Documentation

type Ix1 = Int

pattern Ix1 :: Int -> Ix1

data Ix2

Constructors

(:.) !Int !Int infixr 5

Instances

Bounded Ix2

Methods

minBound :: Ix2

maxBound :: Ix2

Eq Ix2

Methods

(==) :: Ix2 -> Ix2 -> Bool

(/=) :: Ix2 -> Ix2 -> Bool

Num Ix2

Methods

(+) :: Ix2 -> Ix2 -> Ix2

(-) :: Ix2 -> Ix2 -> Ix2

(*) :: Ix2 -> Ix2 -> Ix2

negate :: Ix2 -> Ix2

abs :: Ix2 -> Ix2

signum :: Ix2 -> Ix2

fromInteger :: Integer -> Ix2

Ord Ix2

Methods

compare :: Ix2 -> Ix2 -> Ordering

(<) :: Ix2 -> Ix2 -> Bool

(<=) :: Ix2 -> Ix2 -> Bool

(>) :: Ix2 -> Ix2 -> Bool

(>=) :: Ix2 -> Ix2 -> Bool

max :: Ix2 -> Ix2 -> Ix2

min :: Ix2 -> Ix2 -> Ix2

Show Ix2

Methods

showsPrec :: Int -> Ix2 -> ShowS

show :: Ix2 -> String

showList :: [Ix2] -> ShowS

NFData Ix2

Methods

rnf :: Ix2 -> ()

Unbox Ix2

Unboxing of a Ix2.

Index Ix2

Associated Types

type Rank Ix2 :: Nat

Methods

rank :: Ix2 -> Dim

totalElem :: Ix2 -> Int

consDim :: Int -> Lower Ix2 -> Ix2

unconsDim :: Ix2 -> (Int, Lower Ix2)

snocDim :: Lower Ix2 -> Int -> Ix2

unsnocDim :: Ix2 -> (Lower Ix2, Int)

dropDim :: Ix2 -> Dim -> Maybe (Lower Ix2)

getIndex :: Ix2 -> Dim -> Maybe Int

setIndex :: Ix2 -> Dim -> Int -> Maybe Ix2

pureIndex :: Int -> Ix2

liftIndex2 :: (Int -> Int -> Int) -> Ix2 -> Ix2 -> Ix2

zeroIndex :: Ix2

liftIndex :: (Int -> Int) -> Ix2 -> Ix2

isSafeIndex :: Ix2 -> Ix2 -> Bool

toLinearIndex :: Ix2 -> Ix2 -> Int

toLinearIndexAcc :: Int -> Ix2 -> Ix2 -> Int

fromLinearIndex :: Ix2 -> Int -> Ix2

fromLinearIndexAcc :: Ix2 -> Int -> (Int, Ix2)

repairIndex :: Ix2 -> Ix2 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix2

iter :: Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> a) -> a

iterM :: Monad m => Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> m a) -> m a

iterM_ :: Monad m => Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> (Ix2 -> m a) -> m ()

Vector Vector Ix2

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Ix2 -> m (Vector Ix2)

basicUnsafeThaw :: PrimMonad m => Vector Ix2 -> m (Mutable Vector (PrimState m) Ix2)

basicLength :: Vector Ix2 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Ix2 -> Vector Ix2

basicUnsafeIndexM :: Monad m => Vector Ix2 -> Int -> m Ix2

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Ix2 -> Vector Ix2 -> m ()

elemseq :: Vector Ix2 -> Ix2 -> b -> b

MVector MVector Ix2

Methods

basicLength :: MVector s Ix2 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Ix2 -> MVector s Ix2

basicOverlaps :: MVector s Ix2 -> MVector s Ix2 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Ix2)

basicInitialize :: PrimMonad m => MVector (PrimState m) Ix2 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Ix2 -> m (MVector (PrimState m) Ix2)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> m Ix2

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> Ix2 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Ix2 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Ix2 -> Ix2 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Ix2 -> MVector (PrimState m) Ix2 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Ix2 -> MVector (PrimState m) Ix2 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> m (MVector (PrimState m) Ix2)

Load DW Ix2 e

Methods

loadS :: Monad m => Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array DW Ix2 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

data Vector Ix2

data Vector Ix2 = V_Ix2 (Vector Ix2T)

type Rank Ix2

type Rank Ix2 = 2

type Lower Ix2

type Lower Ix2 = Ix1

data MVector s Ix2

data MVector s Ix2 = MV_Ix2 (MVector s Ix2T)

pattern Ix2 :: Int -> Int -> Ix2

type Ix3 = IxN 3

pattern Ix3 :: Int -> Int -> Int -> Ix3

type Ix4 = IxN 4

pattern Ix4 :: Int -> Int -> Int -> Int -> Ix4

type Ix5 = IxN 5

pattern Ix5 :: Int -> Int -> Int -> Int -> Int -> Ix5

data IxN (n :: Nat) where

Constructors

(:>) :: !Int -> !(Ix (n - 1)) -> IxN n infixr 5

Instances

Bounded Ix3

Methods

minBound :: Ix3

maxBound :: Ix3

Num Ix3

Methods

(+) :: Ix3 -> Ix3 -> Ix3

(-) :: Ix3 -> Ix3 -> Ix3

(*) :: Ix3 -> Ix3 -> Ix3

negate :: Ix3 -> Ix3

abs :: Ix3 -> Ix3

signum :: Ix3 -> Ix3

fromInteger :: Integer -> Ix3

((<=) 3 n, Unbox (Ix ((-) n 1))) => Vector Vector (IxN n)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (IxN n) -> m (Vector (IxN n))

basicUnsafeThaw :: PrimMonad m => Vector (IxN n) -> m (Mutable Vector (PrimState m) (IxN n))

basicLength :: Vector (IxN n) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (IxN n) -> Vector (IxN n)

basicUnsafeIndexM :: Monad m => Vector (IxN n) -> Int -> m (IxN n)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (IxN n) -> Vector (IxN n) -> m ()

elemseq :: Vector (IxN n) -> IxN n -> b -> b

((<=) 3 n, Unbox (Ix ((-) n 1))) => MVector MVector (IxN n)

Methods

basicLength :: MVector s (IxN n) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (IxN n) -> MVector s (IxN n)

basicOverlaps :: MVector s (IxN n) -> MVector s (IxN n) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (IxN n))

basicInitialize :: PrimMonad m => MVector (PrimState m) (IxN n) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> IxN n -> m (MVector (PrimState m) (IxN n))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> m (IxN n)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> IxN n -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (IxN n) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (IxN n) -> IxN n -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (IxN n) -> MVector (PrimState m) (IxN n) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (IxN n) -> MVector (PrimState m) (IxN n) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> m (MVector (PrimState m) (IxN n))

((<=) 4 n, KnownNat n, Index (Ix ((-) n 1)), (~) * (IxN ((-) n 1)) (Ix ((-) n 1))) => Bounded (IxN n)

Methods

minBound :: IxN n

maxBound :: IxN n

Eq (Ix ((-) n 1)) => Eq (IxN n)

Methods

(==) :: IxN n -> IxN n -> Bool

(/=) :: IxN n -> IxN n -> Bool

((<=) 4 n, KnownNat n, Index (Ix ((-) n 1)), (~) * (IxN ((-) n 1)) (Ix ((-) n 1))) => Num (IxN n)

Methods

(+) :: IxN n -> IxN n -> IxN n

(-) :: IxN n -> IxN n -> IxN n

(*) :: IxN n -> IxN n -> IxN n

negate :: IxN n -> IxN n

abs :: IxN n -> IxN n

signum :: IxN n -> IxN n

fromInteger :: Integer -> IxN n

Ord (Ix ((-) n 1)) => Ord (IxN n)

Methods

compare :: IxN n -> IxN n -> Ordering

(<) :: IxN n -> IxN n -> Bool

(<=) :: IxN n -> IxN n -> Bool

(>) :: IxN n -> IxN n -> Bool

(>=) :: IxN n -> IxN n -> Bool

max :: IxN n -> IxN n -> IxN n

min :: IxN n -> IxN n -> IxN n

Show (Ix ((-) n 1)) => Show (IxN n)

Methods

showsPrec :: Int -> IxN n -> ShowS

show :: IxN n -> String

showList :: [IxN n] -> ShowS

NFData (IxN n)

Methods

rnf :: IxN n -> ()

((<=) 3 n, Unbox (Ix ((-) n 1))) => Unbox (IxN n)

Unboxing of a IxN.

((<=) 4 n, KnownNat n, Index (Ix ((-) n 1)), (~) * (IxN ((-) n 1)) (Ix ((-) n 1))) => Index (IxN n)

Associated Types

type Rank (IxN n) :: Nat

Methods

rank :: IxN n -> Dim

totalElem :: IxN n -> Int

consDim :: Int -> Lower (IxN n) -> IxN n

unconsDim :: IxN n -> (Int, Lower (IxN n))

snocDim :: Lower (IxN n) -> Int -> IxN n

unsnocDim :: IxN n -> (Lower (IxN n), Int)

dropDim :: IxN n -> Dim -> Maybe (Lower (IxN n))

getIndex :: IxN n -> Dim -> Maybe Int

setIndex :: IxN n -> Dim -> Int -> Maybe (IxN n)

pureIndex :: Int -> IxN n

liftIndex2 :: (Int -> Int -> Int) -> IxN n -> IxN n -> IxN n

zeroIndex :: IxN n

liftIndex :: (Int -> Int) -> IxN n -> IxN n

isSafeIndex :: IxN n -> IxN n -> Bool

toLinearIndex :: IxN n -> IxN n -> Int

toLinearIndexAcc :: Int -> IxN n -> IxN n -> Int

fromLinearIndex :: IxN n -> Int -> IxN n

fromLinearIndexAcc :: IxN n -> Int -> (Int, IxN n)

repairIndex :: IxN n -> IxN n -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> IxN n

iter :: IxN n -> IxN n -> Int -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> a) -> a

iterM :: Monad m => IxN n -> IxN n -> Int -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> m a) -> m a

iterM_ :: Monad m => IxN n -> IxN n -> Int -> (Int -> Int -> Bool) -> (IxN n -> m a) -> m ()

Index (IxN 3)

Associated Types

type Rank (IxN 3) :: Nat

Methods

rank :: IxN 3 -> Dim

totalElem :: IxN 3 -> Int

consDim :: Int -> Lower (IxN 3) -> IxN 3

unconsDim :: IxN 3 -> (Int, Lower (IxN 3))

snocDim :: Lower (IxN 3) -> Int -> IxN 3

unsnocDim :: IxN 3 -> (Lower (IxN 3), Int)

dropDim :: IxN 3 -> Dim -> Maybe (Lower (IxN 3))

getIndex :: IxN 3 -> Dim -> Maybe Int

setIndex :: IxN 3 -> Dim -> Int -> Maybe (IxN 3)

pureIndex :: Int -> IxN 3

liftIndex2 :: (Int -> Int -> Int) -> IxN 3 -> IxN 3 -> IxN 3

zeroIndex :: IxN 3

liftIndex :: (Int -> Int) -> IxN 3 -> IxN 3

isSafeIndex :: IxN 3 -> IxN 3 -> Bool

toLinearIndex :: IxN 3 -> IxN 3 -> Int

toLinearIndexAcc :: Int -> IxN 3 -> IxN 3 -> Int

fromLinearIndex :: IxN 3 -> Int -> IxN 3

fromLinearIndexAcc :: IxN 3 -> Int -> (Int, IxN 3)

repairIndex :: IxN 3 -> IxN 3 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> IxN 3

iter :: IxN 3 -> IxN 3 -> Int -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> a) -> a

iterM :: Monad m => IxN 3 -> IxN 3 -> Int -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> m a) -> m a

iterM_ :: Monad m => IxN 3 -> IxN 3 -> Int -> (Int -> Int -> Bool) -> (IxN 3 -> m a) -> m ()

type Rank Ix3

type Rank Ix3 = 3

data MVector s (IxN n)

data MVector s (IxN n) = MV_IxN (MVector s Int, MVector s (Ix ((-) n 1)))

data Vector (IxN n)

data Vector (IxN n) = V_IxN (Vector Int, Vector (Ix ((-) n 1)))

type Rank (IxN n)

type Rank (IxN n) = n

type Lower (IxN n)

type Lower (IxN n) = Ix ((-) n 1)

type family Ix (n :: Nat) = r | r -> n where ...

Equations

Ix 0 = Ix0

Ix 1 = Ix1

Ix 2 = Ix2

Ix n = IxN n

toIx2 :: Ix2T -> Ix2

fromIx2 :: Ix2 -> Ix2T

toIx3 :: Ix3T -> Ix3

fromIx3 :: Ix3 -> Ix3T

toIx4 :: Ix4T -> Ix4

fromIx4 :: Ix4 -> Ix4T

toIx5 :: Ix5T -> Ix5

fromIx5 :: Ix5 -> Ix5T

data Border e

Approach to be used near the borders during various transformations. Whenever a function needs information not only about an element of interest, but also about it's neighbours, it will go out of bounds around the image edges, hence is this set of approaches that can be used in such situtation.

Constructors

Fill e

Fill in a constant element.

           outside |  Image  | outside
(Fill 0) : 0 0 0 0 | 1 2 3 4 | 0 0 0 0

Wrap

Wrap around from the opposite border of the array.

           outside |  Image  | outside
Wrap :     1 2 3 4 | 1 2 3 4 | 1 2 3 4

Edge

Replicate the element at the edge.

           outside |  Image  | outside
Edge :     1 1 1 1 | 1 2 3 4 | 4 4 4 4

Reflect

Mirror like reflection.

           outside |  Image  | outside
Reflect :  4 3 2 1 | 1 2 3 4 | 4 3 2 1

Continue

Also mirror like reflection, but without repeating the edge element.

           outside |  Image  | outside
Continue : 1 4 3 2 | 1 2 3 4 | 3 2 1 4

Instances

Eq e => Eq (Border e)

Methods

(==) :: Border e -> Border e -> Bool

(/=) :: Border e -> Border e -> Bool

Show e => Show (Border e)

Methods

showsPrec :: Int -> Border e -> ShowS

show :: Border e -> String

showList :: [Border e] -> ShowS

NFData e => NFData (Border e)

Methods

rnf :: Border e -> ()

handleBorderIndex

Arguments

:: Index ix

=> Border e

Broder resolution technique

-> ix

Size

-> (ix -> e)

Index function that produces an element

-> ix

Index

-> e

Apply a border resolution technique to an index

newtype Dim

Constructors

Dim Int

Instances

Enum Dim

Methods

succ :: Dim -> Dim

pred :: Dim -> Dim

toEnum :: Int -> Dim

fromEnum :: Dim -> Int

enumFrom :: Dim -> [Dim]

enumFromThen :: Dim -> Dim -> [Dim]

enumFromTo :: Dim -> Dim -> [Dim]

enumFromThenTo :: Dim -> Dim -> Dim -> [Dim]

Eq Dim

Methods

(==) :: Dim -> Dim -> Bool

(/=) :: Dim -> Dim -> Bool

Integral Dim

Methods

quot :: Dim -> Dim -> Dim

rem :: Dim -> Dim -> Dim

div :: Dim -> Dim -> Dim

mod :: Dim -> Dim -> Dim

quotRem :: Dim -> Dim -> (Dim, Dim)

divMod :: Dim -> Dim -> (Dim, Dim)

toInteger :: Dim -> Integer

Num Dim

Methods

(+) :: Dim -> Dim -> Dim

(-) :: Dim -> Dim -> Dim

(*) :: Dim -> Dim -> Dim

negate :: Dim -> Dim

abs :: Dim -> Dim

signum :: Dim -> Dim

fromInteger :: Integer -> Dim

Ord Dim

Methods

compare :: Dim -> Dim -> Ordering

(<) :: Dim -> Dim -> Bool

(<=) :: Dim -> Dim -> Bool

(>) :: Dim -> Dim -> Bool

(>=) :: Dim -> Dim -> Bool

max :: Dim -> Dim -> Dim

min :: Dim -> Dim -> Dim

Real Dim

Methods

toRational :: Dim -> Rational

Show Dim

Methods

showsPrec :: Int -> Dim -> ShowS

show :: Dim -> String

showList :: [Dim] -> ShowS

data Ix0

Constructors

Ix0

Instances

Eq Ix0

Methods

(==) :: Ix0 -> Ix0 -> Bool

(/=) :: Ix0 -> Ix0 -> Bool

Ord Ix0

Methods

compare :: Ix0 -> Ix0 -> Ordering

(<) :: Ix0 -> Ix0 -> Bool

(<=) :: Ix0 -> Ix0 -> Bool

(>) :: Ix0 -> Ix0 -> Bool

(>=) :: Ix0 -> Ix0 -> Bool

max :: Ix0 -> Ix0 -> Ix0

min :: Ix0 -> Ix0 -> Ix0

Show Ix0

Methods

showsPrec :: Int -> Ix0 -> ShowS

show :: Ix0 -> String

showList :: [Ix0] -> ShowS

type Ix1T = Int

type Ix2T = (Int, Int)

type Ix3T = (Int, Int, Int)

type Ix4T = (Int, Int, Int, Int)

type Ix5T = (Int, Int, Int, Int, Int)

type family Lower ix :: *

Instances

type Lower Ix5T

type Lower Ix5T = Ix4T

type Lower Ix4T

type Lower Ix4T = Ix3T

type Lower Ix3T

type Lower Ix3T = Ix2T

type Lower Ix2T

type Lower Ix2T = Ix1T

type Lower Ix1T

type Lower Ix1T = Ix0

type Lower Ix2

type Lower Ix2 = Ix1

type Lower (IxN n)

type Lower (IxN n) = Ix ((-) n 1)

class (Eq ix, Ord ix, Show ix, NFData ix) => Index ix where

Minimal complete definition

rank, totalElem, consDim, unconsDim, snocDim, unsnocDim, dropDim, getIndex, setIndex, pureIndex, liftIndex2

Associated Types

type Rank ix :: Nat

Methods

rank :: ix -> Dim

totalElem :: ix -> Int

Total number of elements in an array of this size.

consDim :: Int -> Lower ix -> ix

unconsDim :: ix -> (Int, Lower ix)

snocDim :: Lower ix -> Int -> ix

unsnocDim :: ix -> (Lower ix, Int)

dropDim :: ix -> Dim -> Maybe (Lower ix)

getIndex :: ix -> Dim -> Maybe Int

setIndex :: ix -> Dim -> Int -> Maybe ix

pureIndex :: Int -> ix

liftIndex2 :: (Int -> Int -> Int) -> ix -> ix -> ix

Zip together two indices with a function

zeroIndex :: ix

liftIndex :: (Int -> Int) -> ix -> ix

Map a function over an index

isSafeIndex

Arguments

:: ix

Size

-> ix

Index

-> Bool

Check whether index is within the size.

isSafeIndex

Arguments

:: Index (Lower ix)

=> ix

Size

-> ix

Index

-> Bool

Check whether index is within the size.

toLinearIndex

Arguments

:: ix

Size

-> ix

Index

-> Int

Produce linear index from size and index

toLinearIndex

Arguments

:: Index (Lower ix)

=> ix

Size

-> ix

Index

-> Int

Produce linear index from size and index

toLinearIndexAcc :: Int -> ix -> ix -> Int

toLinearIndexAcc :: Index (Lower ix) => Int -> ix -> ix -> Int

fromLinearIndex :: ix -> Int -> ix

Produce N Dim index from size and linear index

fromLinearIndex :: Index (Lower ix) => ix -> Int -> ix

Produce N Dim index from size and linear index

fromLinearIndexAcc :: ix -> Int -> (Int, ix)

fromLinearIndexAcc :: Index (Lower ix) => ix -> Int -> (Int, ix)

repairIndex :: ix -> ix -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> ix

repairIndex :: Index (Lower ix) => ix -> ix -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> ix

iter :: ix -> ix -> Int -> (Int -> Int -> Bool) -> a -> (ix -> a -> a) -> a

iterM

Arguments

:: Monad m

=> ix

Start index

-> ix

End index

-> Int

Increment

-> (Int -> Int -> Bool)

Continue iteration while predicate is True (eg. until end of row)

-> a

Initial value for an accumulator

-> (ix -> a -> m a)

Accumulator function

-> m a

iterM

Arguments

:: (Index (Lower ix), Monad m)

=> ix

Start index

-> ix

End index

-> Int

Increment

-> (Int -> Int -> Bool)

Continue iteration while predicate is True (eg. until end of row)

-> a

Initial value for an accumulator

-> (ix -> a -> m a)

Accumulator function

-> m a

iterM_ :: Monad m => ix -> ix -> Int -> (Int -> Int -> Bool) -> (ix -> m a) -> m ()

iterM_ :: (Index (Lower ix), Monad m) => ix -> ix -> Int -> (Int -> Int -> Bool) -> (ix -> m a) -> m ()

Instances

Index Ix5T

Associated Types

type Rank Ix5T :: Nat

Methods

rank :: Ix5T -> Dim

totalElem :: Ix5T -> Int

consDim :: Int -> Lower Ix5T -> Ix5T

unconsDim :: Ix5T -> (Int, Lower Ix5T)

snocDim :: Lower Ix5T -> Int -> Ix5T

unsnocDim :: Ix5T -> (Lower Ix5T, Int)

dropDim :: Ix5T -> Dim -> Maybe (Lower Ix5T)

getIndex :: Ix5T -> Dim -> Maybe Int

setIndex :: Ix5T -> Dim -> Int -> Maybe Ix5T

pureIndex :: Int -> Ix5T

liftIndex2 :: (Int -> Int -> Int) -> Ix5T -> Ix5T -> Ix5T

zeroIndex :: Ix5T

liftIndex :: (Int -> Int) -> Ix5T -> Ix5T

isSafeIndex :: Ix5T -> Ix5T -> Bool

toLinearIndex :: Ix5T -> Ix5T -> Int

toLinearIndexAcc :: Int -> Ix5T -> Ix5T -> Int

fromLinearIndex :: Ix5T -> Int -> Ix5T

fromLinearIndexAcc :: Ix5T -> Int -> (Int, Ix5T)

repairIndex :: Ix5T -> Ix5T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix5T

iter :: Ix5T -> Ix5T -> Int -> (Int -> Int -> Bool) -> a -> (Ix5T -> a -> a) -> a

iterM :: Monad m => Ix5T -> Ix5T -> Int -> (Int -> Int -> Bool) -> a -> (Ix5T -> a -> m a) -> m a

iterM_ :: Monad m => Ix5T -> Ix5T -> Int -> (Int -> Int -> Bool) -> (Ix5T -> m a) -> m ()

Index Ix4T

Associated Types

type Rank Ix4T :: Nat

Methods

rank :: Ix4T -> Dim

totalElem :: Ix4T -> Int

consDim :: Int -> Lower Ix4T -> Ix4T

unconsDim :: Ix4T -> (Int, Lower Ix4T)

snocDim :: Lower Ix4T -> Int -> Ix4T

unsnocDim :: Ix4T -> (Lower Ix4T, Int)

dropDim :: Ix4T -> Dim -> Maybe (Lower Ix4T)

getIndex :: Ix4T -> Dim -> Maybe Int

setIndex :: Ix4T -> Dim -> Int -> Maybe Ix4T

pureIndex :: Int -> Ix4T

liftIndex2 :: (Int -> Int -> Int) -> Ix4T -> Ix4T -> Ix4T

zeroIndex :: Ix4T

liftIndex :: (Int -> Int) -> Ix4T -> Ix4T

isSafeIndex :: Ix4T -> Ix4T -> Bool

toLinearIndex :: Ix4T -> Ix4T -> Int

toLinearIndexAcc :: Int -> Ix4T -> Ix4T -> Int

fromLinearIndex :: Ix4T -> Int -> Ix4T

fromLinearIndexAcc :: Ix4T -> Int -> (Int, Ix4T)

repairIndex :: Ix4T -> Ix4T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix4T

iter :: Ix4T -> Ix4T -> Int -> (Int -> Int -> Bool) -> a -> (Ix4T -> a -> a) -> a

iterM :: Monad m => Ix4T -> Ix4T -> Int -> (Int -> Int -> Bool) -> a -> (Ix4T -> a -> m a) -> m a

iterM_ :: Monad m => Ix4T -> Ix4T -> Int -> (Int -> Int -> Bool) -> (Ix4T -> m a) -> m ()

Index Ix3T

Associated Types

type Rank Ix3T :: Nat

Methods

rank :: Ix3T -> Dim

totalElem :: Ix3T -> Int

consDim :: Int -> Lower Ix3T -> Ix3T

unconsDim :: Ix3T -> (Int, Lower Ix3T)

snocDim :: Lower Ix3T -> Int -> Ix3T

unsnocDim :: Ix3T -> (Lower Ix3T, Int)

dropDim :: Ix3T -> Dim -> Maybe (Lower Ix3T)

getIndex :: Ix3T -> Dim -> Maybe Int

setIndex :: Ix3T -> Dim -> Int -> Maybe Ix3T

pureIndex :: Int -> Ix3T

liftIndex2 :: (Int -> Int -> Int) -> Ix3T -> Ix3T -> Ix3T

zeroIndex :: Ix3T

liftIndex :: (Int -> Int) -> Ix3T -> Ix3T

isSafeIndex :: Ix3T -> Ix3T -> Bool

toLinearIndex :: Ix3T -> Ix3T -> Int

toLinearIndexAcc :: Int -> Ix3T -> Ix3T -> Int

fromLinearIndex :: Ix3T -> Int -> Ix3T

fromLinearIndexAcc :: Ix3T -> Int -> (Int, Ix3T)

repairIndex :: Ix3T -> Ix3T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix3T

iter :: Ix3T -> Ix3T -> Int -> (Int -> Int -> Bool) -> a -> (Ix3T -> a -> a) -> a

iterM :: Monad m => Ix3T -> Ix3T -> Int -> (Int -> Int -> Bool) -> a -> (Ix3T -> a -> m a) -> m a

iterM_ :: Monad m => Ix3T -> Ix3T -> Int -> (Int -> Int -> Bool) -> (Ix3T -> m a) -> m ()

Index Ix2T

Associated Types

type Rank Ix2T :: Nat

Methods

rank :: Ix2T -> Dim

totalElem :: Ix2T -> Int

consDim :: Int -> Lower Ix2T -> Ix2T

unconsDim :: Ix2T -> (Int, Lower Ix2T)

snocDim :: Lower Ix2T -> Int -> Ix2T

unsnocDim :: Ix2T -> (Lower Ix2T, Int)

dropDim :: Ix2T -> Dim -> Maybe (Lower Ix2T)

getIndex :: Ix2T -> Dim -> Maybe Int

setIndex :: Ix2T -> Dim -> Int -> Maybe Ix2T

pureIndex :: Int -> Ix2T

liftIndex2 :: (Int -> Int -> Int) -> Ix2T -> Ix2T -> Ix2T

zeroIndex :: Ix2T

liftIndex :: (Int -> Int) -> Ix2T -> Ix2T

isSafeIndex :: Ix2T -> Ix2T -> Bool

toLinearIndex :: Ix2T -> Ix2T -> Int

toLinearIndexAcc :: Int -> Ix2T -> Ix2T -> Int

fromLinearIndex :: Ix2T -> Int -> Ix2T

fromLinearIndexAcc :: Ix2T -> Int -> (Int, Ix2T)

repairIndex :: Ix2T -> Ix2T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix2T

iter :: Ix2T -> Ix2T -> Int -> (Int -> Int -> Bool) -> a -> (Ix2T -> a -> a) -> a

iterM :: Monad m => Ix2T -> Ix2T -> Int -> (Int -> Int -> Bool) -> a -> (Ix2T -> a -> m a) -> m a

iterM_ :: Monad m => Ix2T -> Ix2T -> Int -> (Int -> Int -> Bool) -> (Ix2T -> m a) -> m ()

Index Ix1T

Associated Types

type Rank Ix1T :: Nat

Methods

rank :: Ix1T -> Dim

totalElem :: Ix1T -> Int

consDim :: Int -> Lower Ix1T -> Ix1T

unconsDim :: Ix1T -> (Int, Lower Ix1T)

snocDim :: Lower Ix1T -> Int -> Ix1T

unsnocDim :: Ix1T -> (Lower Ix1T, Int)

dropDim :: Ix1T -> Dim -> Maybe (Lower Ix1T)

getIndex :: Ix1T -> Dim -> Maybe Int

setIndex :: Ix1T -> Dim -> Int -> Maybe Ix1T

pureIndex :: Int -> Ix1T

liftIndex2 :: (Int -> Int -> Int) -> Ix1T -> Ix1T -> Ix1T

zeroIndex :: Ix1T

liftIndex :: (Int -> Int) -> Ix1T -> Ix1T

isSafeIndex :: Ix1T -> Ix1T -> Bool

toLinearIndex :: Ix1T -> Ix1T -> Int

toLinearIndexAcc :: Int -> Ix1T -> Ix1T -> Int

fromLinearIndex :: Ix1T -> Int -> Ix1T

fromLinearIndexAcc :: Ix1T -> Int -> (Int, Ix1T)

repairIndex :: Ix1T -> Ix1T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix1T

iter :: Ix1T -> Ix1T -> Int -> (Int -> Int -> Bool) -> a -> (Ix1T -> a -> a) -> a

iterM :: Monad m => Ix1T -> Ix1T -> Int -> (Int -> Int -> Bool) -> a -> (Ix1T -> a -> m a) -> m a

iterM_ :: Monad m => Ix1T -> Ix1T -> Int -> (Int -> Int -> Bool) -> (Ix1T -> m a) -> m ()

Index Ix2

Associated Types

type Rank Ix2 :: Nat

Methods

rank :: Ix2 -> Dim

totalElem :: Ix2 -> Int

consDim :: Int -> Lower Ix2 -> Ix2

unconsDim :: Ix2 -> (Int, Lower Ix2)

snocDim :: Lower Ix2 -> Int -> Ix2

unsnocDim :: Ix2 -> (Lower Ix2, Int)

dropDim :: Ix2 -> Dim -> Maybe (Lower Ix2)

getIndex :: Ix2 -> Dim -> Maybe Int

setIndex :: Ix2 -> Dim -> Int -> Maybe Ix2

pureIndex :: Int -> Ix2

liftIndex2 :: (Int -> Int -> Int) -> Ix2 -> Ix2 -> Ix2

zeroIndex :: Ix2

liftIndex :: (Int -> Int) -> Ix2 -> Ix2

isSafeIndex :: Ix2 -> Ix2 -> Bool

toLinearIndex :: Ix2 -> Ix2 -> Int

toLinearIndexAcc :: Int -> Ix2 -> Ix2 -> Int

fromLinearIndex :: Ix2 -> Int -> Ix2

fromLinearIndexAcc :: Ix2 -> Int -> (Int, Ix2)

repairIndex :: Ix2 -> Ix2 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix2

iter :: Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> a) -> a

iterM :: Monad m => Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> m a) -> m a

iterM_ :: Monad m => Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> (Ix2 -> m a) -> m ()

((<=) 4 n, KnownNat n, Index (Ix ((-) n 1)), (~) * (IxN ((-) n 1)) (Ix ((-) n 1))) => Index (IxN n)

Associated Types

type Rank (IxN n) :: Nat

Methods

rank :: IxN n -> Dim

totalElem :: IxN n -> Int

consDim :: Int -> Lower (IxN n) -> IxN n

unconsDim :: IxN n -> (Int, Lower (IxN n))

snocDim :: Lower (IxN n) -> Int -> IxN n

unsnocDim :: IxN n -> (Lower (IxN n), Int)

dropDim :: IxN n -> Dim -> Maybe (Lower (IxN n))

getIndex :: IxN n -> Dim -> Maybe Int

setIndex :: IxN n -> Dim -> Int -> Maybe (IxN n)

pureIndex :: Int -> IxN n

liftIndex2 :: (Int -> Int -> Int) -> IxN n -> IxN n -> IxN n

zeroIndex :: IxN n

liftIndex :: (Int -> Int) -> IxN n -> IxN n

isSafeIndex :: IxN n -> IxN n -> Bool

toLinearIndex :: IxN n -> IxN n -> Int

toLinearIndexAcc :: Int -> IxN n -> IxN n -> Int

fromLinearIndex :: IxN n -> Int -> IxN n

fromLinearIndexAcc :: IxN n -> Int -> (Int, IxN n)

repairIndex :: IxN n -> IxN n -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> IxN n

iter :: IxN n -> IxN n -> Int -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> a) -> a

iterM :: Monad m => IxN n -> IxN n -> Int -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> m a) -> m a

iterM_ :: Monad m => IxN n -> IxN n -> Int -> (Int -> Int -> Bool) -> (IxN n -> m a) -> m ()

Index (IxN 3)

Associated Types

type Rank (IxN 3) :: Nat

Methods

rank :: IxN 3 -> Dim

totalElem :: IxN 3 -> Int

consDim :: Int -> Lower (IxN 3) -> IxN 3

unconsDim :: IxN 3 -> (Int, Lower (IxN 3))

snocDim :: Lower (IxN 3) -> Int -> IxN 3

unsnocDim :: IxN 3 -> (Lower (IxN 3), Int)

dropDim :: IxN 3 -> Dim -> Maybe (Lower (IxN 3))

getIndex :: IxN 3 -> Dim -> Maybe Int

setIndex :: IxN 3 -> Dim -> Int -> Maybe (IxN 3)

pureIndex :: Int -> IxN 3

liftIndex2 :: (Int -> Int -> Int) -> IxN 3 -> IxN 3 -> IxN 3

zeroIndex :: IxN 3

liftIndex :: (Int -> Int) -> IxN 3 -> IxN 3

isSafeIndex :: IxN 3 -> IxN 3 -> Bool

toLinearIndex :: IxN 3 -> IxN 3 -> Int

toLinearIndexAcc :: Int -> IxN 3 -> IxN 3 -> Int

fromLinearIndex :: IxN 3 -> Int -> IxN 3

fromLinearIndexAcc :: IxN 3 -> Int -> (Int, IxN 3)

repairIndex :: IxN 3 -> IxN 3 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> IxN 3

iter :: IxN 3 -> IxN 3 -> Int -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> a) -> a

iterM :: Monad m => IxN 3 -> IxN 3 -> Int -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> m a) -> m a

iterM_ :: Monad m => IxN 3 -> IxN 3 -> Int -> (Int -> Int -> Bool) -> (IxN 3 -> m a) -> m ()

errorIx :: (Show ix, Show ix') => String -> ix -> ix' -> a

isSafeSize :: Index ix => ix -> Bool

Checks whether the size is valid.

isNonEmpty :: Index ix => ix -> Bool

Checks whether array with this size can hold at least one element.

headDim :: Index ix => ix -> Int

tailDim :: Index ix => ix -> Lower ix

lastDim :: Index ix => ix -> Int

initDim :: Index ix => ix -> Lower ix

iterLinearM

Arguments

:: (Index ix, Monad m)

=> ix

Size

-> Int

Linear start

-> Int

Linear end

-> Int

Increment

-> (Int -> Int -> Bool)

Continuation condition (continue if True)

-> a

Accumulator

-> (Int -> ix -> a -> m a)

-> m a

Iterate over N-dimensional space from start to end with accumulator

iterLinearM_

Arguments

:: (Index ix, Monad m)

=> ix

Size

-> Int

Start

-> Int

End

-> Int

Increment

-> (Int -> Int -> Bool)

Continuation condition

-> (Int -> ix -> m ())

Monadic action that takes index in both forms

-> m ()

loop :: Int -> (Int -> Bool) -> (Int -> Int) -> a -> (Int -> a -> a) -> a

Efficient loop with an accumulator

loopM :: Monad m => Int -> (Int -> Bool) -> (Int -> Int) -> a -> (Int -> a -> m a) -> m a

Very efficient monadic loop with an accumulator

loopM_ :: Monad m => Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m a) -> m ()

Efficient monadic loop. Result of each iteration is discarded.