Data.Massiv.Core.Index

Documentation

type Ix1 = Int

Another type synonym for 1-dimensional index, i.e. Int and Ix1T. Provided here purely for consistency.

pattern Ix1 :: Int -> Ix1

This is a very handy pattern synonym to indicate that any arbitrary whole number is an Int, i.e. a 1-dimensional index: (Ix1 i) == (i :: Int)

data Ix2

2-dimensional index. This also a base index for higher dimensions.

Constructors

(:.) !Int !Int infixr 5

Instances

Bounded Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

minBound :: Ix2

maxBound :: Ix2

Eq Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

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

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

Num Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

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

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

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

negate :: Ix2 -> Ix2

abs :: Ix2 -> Ix2

signum :: Ix2 -> Ix2

fromInteger :: Integer -> Ix2

Ord Ix2

Defined in Data.Massiv.Core.Index.Ix

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

Defined in Data.Massiv.Core.Index.Ix

Methods

showsPrec :: Int -> Ix2 -> ShowS

show :: Ix2 -> String

showList :: [Ix2] -> ShowS

NFData Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

rnf :: Ix2 -> ()

Unbox Ix2

Unboxing of a Ix2.

Defined in Data.Massiv.Core.Index.Ix

Index Ix2

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions Ix2 :: Nat

Methods

dimensions :: 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)

pullOutDim :: Ix2 -> Dim -> Maybe (Int, Lower Ix2)

insertDim :: Lower Ix2 -> Dim -> Int -> Maybe Ix2

getDim :: Ix2 -> Dim -> Maybe Int

setDim :: Ix2 -> Dim -> Int -> Maybe Ix2

getIndex :: Ix2 -> Dim -> Maybe Int

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

pureIndex :: Int -> Ix2

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

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

foldlIndex :: (a -> Int -> a) -> a -> Ix2 -> a

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 -> Ix2 -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> a) -> a

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

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

Vector Vector Ix2

Defined in Data.Massiv.Core.Index.Ix

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

Defined in Data.Massiv.Core.Index.Ix

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

Defined in Data.Massiv.Array.Delayed.Windowed

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 ()

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

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

data Vector Ix2

Defined in Data.Massiv.Core.Index.Ix

data Vector Ix2 = V_Ix2 (Vector Ix2T)

type Dimensions Ix2

Defined in Data.Massiv.Core.Index.Ix

type Dimensions Ix2 = 2

type Lower Ix2

Defined in Data.Massiv.Core.Index.Ix

type Lower Ix2 = Ix1

data MVector s Ix2

Defined in Data.Massiv.Core.Index.Ix

data MVector s Ix2 = MV_Ix2 (MVector s Ix2T)

pattern Ix2 :: Int -> Int -> Ix2

2-dimensional index constructor. Useful when TypeOperators extension isn't enabled, or simply infix notation is inconvenient. (Ix2 i j) == (i :. j).

type Ix3 = IxN 3

3-dimensional type synonym. Useful as a alternative to enabling DataKinds and using type level Nats.

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

3-dimensional index constructor. (Ix3 i j k) == (i :> j :. k).

type Ix4 = IxN 4

4-dimensional type synonym.

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

4-dimensional index constructor. (Ix4 i j k l) == (i :> j :> k :. l).

type Ix5 = IxN 5

5-dimensional type synonym.

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

5-dimensional index constructor. (Ix5 i j k l m) = (i :> j :> k :> l :. m).

data IxN (n :: Nat)

n-dimensional index. Needs a base case, which is the Ix2.

Constructors

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

Instances

Bounded Ix3

Defined in Data.Massiv.Core.Index.Ix

Methods

minBound :: Ix3

maxBound :: Ix3

Num Ix3

Defined in Data.Massiv.Core.Index.Ix

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)

Defined in Data.Massiv.Core.Index.Ix

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)

Defined in Data.Massiv.Core.Index.Ix

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))

(Index (IxN n), Load DW (Ix (n - 1)) e) => Load DW (IxN n) e

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

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

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

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride (IxN n) -> IxN n -> Array DW (IxN n) e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array DW (IxN n) e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

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

Defined in Data.Massiv.Core.Index.Ix

Methods

minBound :: IxN n

maxBound :: IxN n

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

Defined in Data.Massiv.Core.Index.Ix

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)

Defined in Data.Massiv.Core.Index.Ix

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)

Defined in Data.Massiv.Core.Index.Ix

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)

Defined in Data.Massiv.Core.Index.Ix

Methods

showsPrec :: Int -> IxN n -> ShowS

show :: IxN n -> String

showList :: [IxN n] -> ShowS

NFData (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

rnf :: IxN n -> ()

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

Unboxing of a IxN.

Defined in Data.Massiv.Core.Index.Ix

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

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions (IxN n) :: Nat

Methods

dimensions :: 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))

pullOutDim :: IxN n -> Dim -> Maybe (Int, Lower (IxN n))

insertDim :: Lower (IxN n) -> Dim -> Int -> Maybe (IxN n)

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

setDim :: IxN n -> Dim -> Int -> Maybe (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

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

foldlIndex :: (a -> Int -> a) -> a -> IxN n -> a

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 -> IxN n -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> a) -> a

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

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

Index (IxN 3)

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions (IxN 3) :: Nat

Methods

dimensions :: 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))

pullOutDim :: IxN 3 -> Dim -> Maybe (Int, Lower (IxN 3))

insertDim :: Lower (IxN 3) -> Dim -> Int -> Maybe (IxN 3)

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

setDim :: IxN 3 -> Dim -> Int -> Maybe (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

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

foldlIndex :: (a -> Int -> a) -> a -> IxN 3 -> a

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 -> IxN 3 -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> a) -> a

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

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

type Dimensions Ix3

Defined in Data.Massiv.Core.Index.Ix

type Dimensions Ix3 = 3

data MVector s (IxN n)

Defined in Data.Massiv.Core.Index.Ix

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

data Vector (IxN n)

Defined in Data.Massiv.Core.Index.Ix

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

type Dimensions (IxN n)

Defined in Data.Massiv.Core.Index.Ix

type Dimensions (IxN n) = n

type Lower (IxN n)

Defined in Data.Massiv.Core.Index.Ix

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

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

Defines n-dimensional index by relating a general IxN with few base cases.

Equations

Ix 0 = Ix0

Ix 1 = Ix1

Ix 2 = Ix2

Ix n = IxN n

toIx2 :: Ix2T -> Ix2

Convert a Int tuple to Ix2

fromIx2 :: Ix2 -> Ix2T

Convert an Ix2 to Int tuple

toIx3 :: Ix3T -> Ix3

Convert a Int 3-tuple to Ix3

fromIx3 :: Ix3 -> Ix3T

Convert an Ix3 to Int 3-tuple

toIx4 :: Ix4T -> Ix4

Convert a Int 4-tuple to Ix4

fromIx4 :: Ix4 -> Ix4T

Convert an Ix4 to Int 4-tuple

toIx5 :: Ix5T -> Ix5

Convert a Int 5-tuple to Ix5

fromIx5 :: Ix5 -> Ix5T

Convert an Ix5 to Int 5-tuple

data Stride ix

Stride provides a way to ignore elements of an array if an index is divisible by a corresponding value in a stride. So, for a Stride (i :. j) only elements with indices will be kept around:

( 0 :. 0) ( 0 :. j) ( 0 :. 2j) ( 0 :. 3j) ...
( i :. 0) ( i :. j) ( i :. 2j) ( i :. 3j) ...
(2i :. 0) (2i :. j) (2i :. 2j) (2i :. 3j) ...
...

Only positive strides make sense, so Stride pattern synonym constructor will prevent a user from creating a stride with negative or zero values, thus promoting safety of the library.

Examples:

• Default and minimal stride of Stride (pureIndex 1) will have no affect and all elements will kept.
• If stride is Stride 2, then every 2nd element (i.e. with index 1, 3, 5, ..) will be skipped and only elemnts with indices divisible by 2 will be kept around.
• In case of two dimensions, if what you want is to keep all rows divisible by 5, but keep every column intact then you'd use Stride (5 :. 1).

Instances

Eq ix => Eq (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

(==) :: Stride ix -> Stride ix -> Bool

(/=) :: Stride ix -> Stride ix -> Bool

Ord ix => Ord (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

compare :: Stride ix -> Stride ix -> Ordering

(<) :: Stride ix -> Stride ix -> Bool

(<=) :: Stride ix -> Stride ix -> Bool

(>) :: Stride ix -> Stride ix -> Bool

(>=) :: Stride ix -> Stride ix -> Bool

max :: Stride ix -> Stride ix -> Stride ix

min :: Stride ix -> Stride ix -> Stride ix

Index ix => Show (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

showsPrec :: Int -> Stride ix -> ShowS

show :: Stride ix -> String

showList :: [Stride ix] -> ShowS

NFData ix => NFData (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

rnf :: Stride ix -> ()

pattern Stride :: Index ix => ix -> Stride ix

A safe bidirectional pattern synonym for Stride construction that will make sure stride elements are always positive.

unStride :: Stride ix -> ix

Just a helper function for unwrapping Stride.

toLinearIndexStride

Arguments

:: Index ix

=> Stride ix

Stride

-> ix

Size

-> ix

Index

-> Int

Compute an index with stride using the original size and index

strideStart :: Index ix => Stride ix -> ix -> ix

Adjust strating index according to the stride

strideSize :: Index ix => Stride ix -> ix -> ix

Adjust size according to the stride.

oneStride :: Index ix => Stride ix

A default stride of 1, where all elements are kept

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 neighbors, it will go out of bounds near the array edges, hence is this set of approaches that specify how to handle such situation.

Constructors

Fill e

Fill in a constant element.

           outside |  Array  | 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 |  Array  | outside
Wrap :     1 2 3 4 | 1 2 3 4 | 1 2 3 4

Edge

Replicate the element at the edge.

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

Reflect

Mirror like reflection.

           outside |  Array  | 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 |  Array  | outside
Continue : 1 4 3 2 | 1 2 3 4 | 3 2 1 4

Instances

Eq e => Eq (Border e)

Defined in Data.Massiv.Core.Index

Methods

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

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

Show e => Show (Border e)

Defined in Data.Massiv.Core.Index

Methods

showsPrec :: Int -> Border e -> ShowS

show :: Border e -> String

showList :: [Border e] -> ShowS

NFData e => NFData (Border e)

Defined in Data.Massiv.Core.Index

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

A way to select Array dimension at a value level.

Constructors

Dim Int

Instances

Enum Dim

Defined in Data.Massiv.Core.Index.Class

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

Defined in Data.Massiv.Core.Index.Class

Methods

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

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

Integral Dim

Defined in Data.Massiv.Core.Index.Class

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

Defined in Data.Massiv.Core.Index.Class

Methods

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

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

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

negate :: Dim -> Dim

abs :: Dim -> Dim

signum :: Dim -> Dim

fromInteger :: Integer -> Dim

Ord Dim

Defined in Data.Massiv.Core.Index.Class

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

Defined in Data.Massiv.Core.Index.Class

Methods

toRational :: Dim -> Rational

Show Dim

Defined in Data.Massiv.Core.Index.Class

Methods

showsPrec :: Int -> Dim -> ShowS

show :: Dim -> String

showList :: [Dim] -> ShowS

data Dimension (n :: Nat) where

A way to select Array dimension at a type level.

Constructors

Dim1 :: Dimension 1

Dim2 :: Dimension 2

Dim3 :: Dimension 3

Dim4 :: Dimension 4

Dim5 :: Dimension 5

DimN :: (6 <= n, KnownNat n) => Dimension n

type IsIndexDimension ix n = (1 <= n, n <= Dimensions ix, Index ix, KnownNat n)

A type level constraint that ensures index is indeed valid and that supplied dimension can be safely used with it.

data Ix0

Zero-dimension, i.e. a scalar. Can't really be used directly as there are no instances of Index for it, and is included for completeness.

Constructors

Ix0

Instances

Eq Ix0

Defined in Data.Massiv.Core.Index.Class

Methods

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

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

Ord Ix0

Defined in Data.Massiv.Core.Index.Class

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

Defined in Data.Massiv.Core.Index.Class

Methods

showsPrec :: Int -> Ix0 -> ShowS

show :: Ix0 -> String

showList :: [Ix0] -> ShowS

type Ix1T = Int

1-dimensional index. Synonym for Int and Ix1.

type Ix2T = (Int, Int)

2-dimensional index as tuple of Ints.

type Ix3T = (Int, Int, Int)

3-dimensional index as 3-tuple of Ints.

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

4-dimensional index as 4-tuple of Ints.

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

5-dimensional index as 5-tuple of Ints.

type family Lower ix :: *

This type family will always point to a type for a dimension that is one lower than the type argument.

Instances

type Lower Ix5T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix5T = Ix4T

type Lower Ix4T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix4T = Ix3T

type Lower Ix3T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix3T = Ix2T

type Lower Ix2T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix2T = Ix1T

type Lower Ix1T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix1T = Ix0

type Lower Ix2

Defined in Data.Massiv.Core.Index.Ix

type Lower Ix2 = Ix1

type Lower (IxN n)

Defined in Data.Massiv.Core.Index.Ix

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

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

This is bread and butter of multi-dimensional array indexing. It is unlikely that any of the functions in this class will be useful to a regular user, unless general algorithms are being implemented that do span multiple dimensions.

Minimal complete definition

dimensions, totalElem, consDim, unconsDim, snocDim, unsnocDim, pullOutDim, insertDim, pureIndex, liftIndex2

Associated Types

type Dimensions ix :: Nat

Methods

dimensions :: ix -> Dim

Dimensions of an array that has this index type, i.e. what is the dimensionality.

totalElem :: ix -> Int

Total number of elements in an array of this size.

consDim :: Int -> Lower ix -> ix

Prepend a dimension to the index

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

Take a dimension from the index from the outside

snocDim :: Lower ix -> Int -> ix

Apppend a dimension to the index

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

Take a dimension from the index from the inside

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

Remove a dimension from the index

pullOutDim :: ix -> Dim -> Maybe (Int, Lower ix)

Pull out value at specified dimension from the index, thus also lowering it dimensionality.

insertDim :: Lower ix -> Dim -> Int -> Maybe ix

Insert a dimension into the index

getDim :: ix -> Dim -> Maybe Int

Extract the value index has at specified dimension.

setDim :: ix -> Dim -> Int -> Maybe ix

Set the value for an index at specified dimension.

getIndex :: ix -> Dim -> Maybe Int

Extract the value index has at specified dimension. To be deprecated.

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

Set the value for an index at specified dimension. To be deprecated.

pureIndex :: Int -> ix

Lift an Int to any index by replicating the value as many times as there are dimensions.

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

Zip together two indices with a function

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

Map a function over an index

foldlIndex :: (a -> Int -> a) -> a -> ix -> a

foldlIndex :: Index (Lower ix) => (a -> Int -> a) -> a -> ix -> a

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

Convert linear index from size and index

toLinearIndex

Arguments

:: Index (Lower ix)

=> ix

Size

-> ix

Index

-> Int

Convert linear index from size and index

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

Convert linear index from size and index with an accumulator. Currently is useless and will likley be removed in future versions.

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

Convert linear index from size and index with an accumulator. Currently is useless and will likley be removed in future versions.

fromLinearIndex :: ix -> Int -> ix

Compute an index from size and linear index

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

Compute an index from size and linear index

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

Compute an index from size and linear index using an accumulator, thus trying to optimize for tail recursion while getting the index computed.

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

Compute an index from size and linear index using an accumulator, thus trying to optimize for tail recursion while getting the index computed.

repairIndex

Arguments

:: ix

Size

-> ix

Index

-> (Int -> Int -> Int)

Repair when below zero

-> (Int -> Int -> Int)

Repair when higher than size

-> ix

A way to make sure index is withing the bounds for the supplied size. Takes two functions that will be invoked whenever index (2nd arg) is outsize the supplied size (1st arg)

repairIndex

Arguments

:: Index (Lower ix)

=> ix

Size

-> ix

Index

-> (Int -> Int -> Int)

Repair when below zero

-> (Int -> Int -> Int)

Repair when higher than size

-> ix

A way to make sure index is withing the bounds for the supplied size. Takes two functions that will be invoked whenever index (2nd arg) is outsize the supplied size (1st arg)

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

Iterator for the index. Same as iterM, but pure.

iterM

Arguments

:: Monad m

=> ix

Start index

-> ix

End index

-> ix

Increment

-> (Int -> Int -> Bool)

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

-> a

Initial value for an accumulator

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

Accumulator function

-> m a

This function is what makes it possible to iterate over an array of any dimension.

iterM

Arguments

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

=> ix

Start index

-> ix

End index

-> ix

Increment

-> (Int -> Int -> Bool)

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

-> a

Initial value for an accumulator

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

Accumulator function

-> m a

This function is what makes it possible to iterate over an array of any dimension.

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

Same as iterM, but don't bother with accumulator and return value.

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

Same as iterM, but don't bother with accumulator and return value.

Instances

Index Ix5T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix5T :: Nat

Methods

dimensions :: 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)

pullOutDim :: Ix5T -> Dim -> Maybe (Int, Lower Ix5T)

insertDim :: Lower Ix5T -> Dim -> Int -> Maybe Ix5T

getDim :: Ix5T -> Dim -> Maybe Int

setDim :: Ix5T -> Dim -> Int -> Maybe Ix5T

getIndex :: Ix5T -> Dim -> Maybe Int

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

pureIndex :: Int -> Ix5T

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

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

foldlIndex :: (a -> Int -> a) -> a -> Ix5T -> a

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 -> Ix5T -> (Int -> Int -> Bool) -> a -> (Ix5T -> a -> a) -> a

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

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

Index Ix4T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix4T :: Nat

Methods

dimensions :: 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)

pullOutDim :: Ix4T -> Dim -> Maybe (Int, Lower Ix4T)

insertDim :: Lower Ix4T -> Dim -> Int -> Maybe Ix4T

getDim :: Ix4T -> Dim -> Maybe Int

setDim :: Ix4T -> Dim -> Int -> Maybe Ix4T

getIndex :: Ix4T -> Dim -> Maybe Int

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

pureIndex :: Int -> Ix4T

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

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

foldlIndex :: (a -> Int -> a) -> a -> Ix4T -> a

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 -> Ix4T -> (Int -> Int -> Bool) -> a -> (Ix4T -> a -> a) -> a

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

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

Index Ix3T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix3T :: Nat

Methods

dimensions :: 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)

pullOutDim :: Ix3T -> Dim -> Maybe (Int, Lower Ix3T)

insertDim :: Lower Ix3T -> Dim -> Int -> Maybe Ix3T

getDim :: Ix3T -> Dim -> Maybe Int

setDim :: Ix3T -> Dim -> Int -> Maybe Ix3T

getIndex :: Ix3T -> Dim -> Maybe Int

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

pureIndex :: Int -> Ix3T

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

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

foldlIndex :: (a -> Int -> a) -> a -> Ix3T -> a

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 -> Ix3T -> (Int -> Int -> Bool) -> a -> (Ix3T -> a -> a) -> a

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

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

Index Ix2T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix2T :: Nat

Methods

dimensions :: 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)

pullOutDim :: Ix2T -> Dim -> Maybe (Int, Lower Ix2T)

insertDim :: Lower Ix2T -> Dim -> Int -> Maybe Ix2T

getDim :: Ix2T -> Dim -> Maybe Int

setDim :: Ix2T -> Dim -> Int -> Maybe Ix2T

getIndex :: Ix2T -> Dim -> Maybe Int

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

pureIndex :: Int -> Ix2T

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

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

foldlIndex :: (a -> Int -> a) -> a -> Ix2T -> a

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 -> Ix2T -> (Int -> Int -> Bool) -> a -> (Ix2T -> a -> a) -> a

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

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

Index Ix1T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix1T :: Nat

Methods

dimensions :: 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)

pullOutDim :: Ix1T -> Dim -> Maybe (Int, Lower Ix1T)

insertDim :: Lower Ix1T -> Dim -> Int -> Maybe Ix1T

getDim :: Ix1T -> Dim -> Maybe Int

setDim :: Ix1T -> Dim -> Int -> Maybe Ix1T

getIndex :: Ix1T -> Dim -> Maybe Int

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

pureIndex :: Int -> Ix1T

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

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

foldlIndex :: (a -> Int -> a) -> a -> Ix1T -> a

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 -> Ix1T -> (Int -> Int -> Bool) -> a -> (Ix1T -> a -> a) -> a

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

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

Index Ix2

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions Ix2 :: Nat

Methods

dimensions :: 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)

pullOutDim :: Ix2 -> Dim -> Maybe (Int, Lower Ix2)

insertDim :: Lower Ix2 -> Dim -> Int -> Maybe Ix2

getDim :: Ix2 -> Dim -> Maybe Int

setDim :: Ix2 -> Dim -> Int -> Maybe Ix2

getIndex :: Ix2 -> Dim -> Maybe Int

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

pureIndex :: Int -> Ix2

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

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

foldlIndex :: (a -> Int -> a) -> a -> Ix2 -> a

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 -> Ix2 -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> a) -> a

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

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

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

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions (IxN n) :: Nat

Methods

dimensions :: 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))

pullOutDim :: IxN n -> Dim -> Maybe (Int, Lower (IxN n))

insertDim :: Lower (IxN n) -> Dim -> Int -> Maybe (IxN n)

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

setDim :: IxN n -> Dim -> Int -> Maybe (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

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

foldlIndex :: (a -> Int -> a) -> a -> IxN n -> a

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 -> IxN n -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> a) -> a

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

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

Index (IxN 3)

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions (IxN 3) :: Nat

Methods

dimensions :: 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))

pullOutDim :: IxN 3 -> Dim -> Maybe (Int, Lower (IxN 3))

insertDim :: Lower (IxN 3) -> Dim -> Int -> Maybe (IxN 3)

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

setDim :: IxN 3 -> Dim -> Int -> Maybe (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

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

foldlIndex :: (a -> Int -> a) -> a -> IxN 3 -> a

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 -> IxN 3 -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> a) -> a

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

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

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

Helper function for throwing out of bounds errors

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

Helper function for throwing error when sizes do not match

zeroIndex :: Index ix => ix

Index with all zeros

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

getIndex' :: Index ix => ix -> Dim -> Int

To be deprecated in favor of getDim'.

setIndex' :: Index ix => ix -> Dim -> Int -> ix

To be deprecated in favor of setDim'.

getDim' :: Index ix => ix -> Dim -> Int

setDim' :: Index ix => ix -> Dim -> Int -> ix

dropDim' :: Index ix => ix -> Dim -> Lower ix

pullOutDim' :: Index ix => ix -> Dim -> (Int, Lower ix)

insertDim' :: Index ix => Lower ix -> Dim -> Int -> ix

fromDimension :: KnownNat n => Dimension n -> Dim

getDimension :: IsIndexDimension ix n => ix -> Dimension n -> Int

Type safe way to extract value of index at a particular dimension.

Since: 0.2.4

setDimension :: IsIndexDimension ix n => ix -> Dimension n -> Int -> ix

Type safe way to set value of index at a particular dimension.

Since: 0.2.4

dropDimension :: IsIndexDimension ix n => ix -> Dimension n -> Lower ix

Type safe way of dropping a particular dimension, thus lowering index dimensionality.

Since: 0.2.4

pullOutDimension :: IsIndexDimension ix n => ix -> Dimension n -> (Int, Lower ix)

Type safe way of pulling out a particular dimension, thus lowering index dimensionality and returning the value at specified dimension.

Since: 0.2.4

insertDimension :: IsIndexDimension ix n => ix -> Dimension n -> Lower ix

Type safe way of inserting a particular dimension, thus raising index dimensionality.

Since: 0.2.4

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 lenarly from start to end in row-major fashion with an 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 ()

Same as iterLinearM, except without an accumulator.

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.

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

Less efficient monadic loop with an accumulator that reverses the direction of action application

splitLinearly :: Int -> Int -> (Int -> Int -> a) -> a

splitLinearlyWith_ :: Monad m => Int -> (m () -> m a) -> Int -> (Int -> b) -> (Int -> b -> m ()) -> m a