SDP.Index

The Index class is a fork of Ix with a richer interface, more convenient function names and generalized indexes.

Shapes

module SDP.Nullable

module SDP.Shape

type family i :|: j where ...

(:|:) is closed type family of shape differences.

Equations

i :|: E = i

i :|: j = DimInit i :|: DimInit j

type SubIndex = Sub

SubIndex is service constraint that corresponds closed (internal) class Sub. SubIndex i j matches if Index type i is subspace of Index type j.

takeDim :: Sub i j => i -> j

Take some dimensions.

>>> takeDim ([1, 2, 3, 4] :: I4 Int) :: I1 Int
[1]
>>> takeDim ([1, 2, 3, 4] :: I4 Int) :: E
E

dropDim :: Sub i j => i -> j -> i :|: j

Drop some dimensions (second argument used as type variable).

>>> dropDim ([1, 2, 3, 4] :: I4 Int) ([] :: E)
[1, 2, 3, 4]
>>> dropDim ([1, 2, 3, 4] :: I4 Int) ([1, 2] :: I2 Int)
[3, 4]

joinDim :: Sub i j => j -> (i :|: j) -> i

Join some dimensions.

>>> joinDim ([1, 2] :: I2 Int) [3] :: I3 Int
[1, 2, 3]
>>> joinDim ([1, 2] :: I2 Int) [3, 4] :: I4 Int
[1, 2, 3, 4]

splitDim :: SubIndex i j => i -> (i :|: j, j)

splitDim returns pair of shape difference and subshape.

Indices

class (Ord i, Shape i, Shape (DimLast i), Shape (DimInit i), Shape (GIndex i)) => Index i where

Index is service class based on base Ix and repa Shape.

Basic rules:

size bnds >= 0
size bnds == product (sizes bnds)

isEmpty bnds == (size bnds == 0)
isEmpty bnds == inRange bnds (safeElem bnds i)

isEmpty bnds => isOverflow  bnds i
isEmpty bnds => isUnderflow bnds i

inRange bnds i /= isEmpty     bnds
inRange bnds i /= isOverflow  bnds i
inRange bnds i /= isUnderflow bnds i
inRange bnds i == (safeElem bnds i == i)

Note:

• E is (and should remain) the one and only one index of rank 0.
• Index is a generalization of Enum, so all rank 1 indices must satisfy Enum laws.
• The cardinality of the set of permissible values for indices mustn't exceed 1 (cardinality of a series of natural numbers), so Fractional types cannot be indices.

Minimal complete definition

Nothing

Methods

size :: (i, i) -> Int

Returns the size of range.

default size :: Enum i => (i, i) -> Int

sizes :: (i, i) -> [Int]

Returns the sizes of range dimensionwise.

default sizes :: Index (GIndex i) => (i, i) -> [Int]

safeElem :: (i, i) -> i -> i

Returns the index belonging to the given range.

ordBounds :: (i, i) -> (i, i)

Returns bounds of nonempty range (swaps bounds in each empty subshape).

defLimit :: i -> Integer

Returns size of biggest range, that may be represented by this type.

default defLimit :: (Integral i, Bounded i) => i -> Integer

defaultBounds :: Int -> (i, i)

Returns default range by size.

unsafeIndex :: Int -> i

Returns index by offset in default range.

default unsafeIndex :: Enum i => Int -> i

isEmpty :: (i, i) -> Bool

Checks if the bounds is empty.

inBounds :: (i, i) -> i -> InBounds

Checks the index status in bounds.

isOverflow :: (i, i) -> i -> Bool

Checks if the index is overflow.

isUnderflow :: (i, i) -> i -> Bool

Checks if the index is underflow.

inRange :: (i, i) -> i -> Bool

Checks if the index is in range.

prev :: (i, i) -> i -> i

Returns previous index in range.

default prev :: Enum i => (i, i) -> i -> i

next :: (i, i) -> i -> i

Returns next index in range.

default next :: Enum i => (i, i) -> i -> i

offset :: (i, i) -> i -> Int

Returns offset (indent) of index in range.

default offset :: Enum i => (i, i) -> i -> Int

index :: (i, i) -> Int -> i

Returns index by this offset (indent) in range.

default index :: Enum i => (i, i) -> Int -> i

range :: (i, i) -> [i]

Returns the ordered list of indices in this range.

default range :: Enum i => (i, i) -> [i]

subshape :: (Sub i j, Index (i :|: j)) => (i, i) -> (i :|: j) -> (j, j)

subshape bnds ij returns subshape of bnds.

Checks if ij in bnds subshape, may throw IndexException.

slice :: (Sub i j, ij ~ (i :|: j), Index j) => (i, i) -> ij -> ((ij, ij), (j, j))

Instances

Index Char

Defined in SDP.Index

Methods

size :: (Char, Char) -> Int

sizes :: (Char, Char) -> [Int]

safeElem :: (Char, Char) -> Char -> Char

ordBounds :: (Char, Char) -> (Char, Char)

defLimit :: Char -> Integer

defaultBounds :: Int -> (Char, Char)

unsafeIndex :: Int -> Char

isEmpty :: (Char, Char) -> Bool

inBounds :: (Char, Char) -> Char -> InBounds

isOverflow :: (Char, Char) -> Char -> Bool

isUnderflow :: (Char, Char) -> Char -> Bool

inRange :: (Char, Char) -> Char -> Bool

prev :: (Char, Char) -> Char -> Char

next :: (Char, Char) -> Char -> Char

offset :: (Char, Char) -> Char -> Int

index :: (Char, Char) -> Int -> Char

range :: (Char, Char) -> [Char]

subshape :: (Sub Char j, Index (Char :|: j)) => (Char, Char) -> (Char :|: j) -> (j, j)

slice :: (Sub Char j, ij ~ (Char :|: j), Index j) => (Char, Char) -> ij -> ((ij, ij), (j, j))

Index Int

Defined in SDP.Index

Methods

size :: (Int, Int) -> Int

sizes :: (Int, Int) -> [Int]

safeElem :: (Int, Int) -> Int -> Int

ordBounds :: (Int, Int) -> (Int, Int)

defLimit :: Int -> Integer

defaultBounds :: Int -> (Int, Int)

unsafeIndex :: Int -> Int

isEmpty :: (Int, Int) -> Bool

inBounds :: (Int, Int) -> Int -> InBounds

isOverflow :: (Int, Int) -> Int -> Bool

isUnderflow :: (Int, Int) -> Int -> Bool

inRange :: (Int, Int) -> Int -> Bool

prev :: (Int, Int) -> Int -> Int

next :: (Int, Int) -> Int -> Int

offset :: (Int, Int) -> Int -> Int

index :: (Int, Int) -> Int -> Int

range :: (Int, Int) -> [Int]

subshape :: (Sub Int j, Index (Int :|: j)) => (Int, Int) -> (Int :|: j) -> (j, j)

slice :: (Sub Int j, ij ~ (Int :|: j), Index j) => (Int, Int) -> ij -> ((ij, ij), (j, j))

Index Int8

Defined in SDP.Index

Methods

size :: (Int8, Int8) -> Int

sizes :: (Int8, Int8) -> [Int]

safeElem :: (Int8, Int8) -> Int8 -> Int8

ordBounds :: (Int8, Int8) -> (Int8, Int8)

defLimit :: Int8 -> Integer

defaultBounds :: Int -> (Int8, Int8)

unsafeIndex :: Int -> Int8

isEmpty :: (Int8, Int8) -> Bool

inBounds :: (Int8, Int8) -> Int8 -> InBounds

isOverflow :: (Int8, Int8) -> Int8 -> Bool

isUnderflow :: (Int8, Int8) -> Int8 -> Bool

inRange :: (Int8, Int8) -> Int8 -> Bool

prev :: (Int8, Int8) -> Int8 -> Int8

next :: (Int8, Int8) -> Int8 -> Int8

offset :: (Int8, Int8) -> Int8 -> Int

index :: (Int8, Int8) -> Int -> Int8

range :: (Int8, Int8) -> [Int8]

subshape :: (Sub Int8 j, Index (Int8 :|: j)) => (Int8, Int8) -> (Int8 :|: j) -> (j, j)

slice :: (Sub Int8 j, ij ~ (Int8 :|: j), Index j) => (Int8, Int8) -> ij -> ((ij, ij), (j, j))

Index Int16

Defined in SDP.Index

Methods

size :: (Int16, Int16) -> Int

sizes :: (Int16, Int16) -> [Int]

safeElem :: (Int16, Int16) -> Int16 -> Int16

ordBounds :: (Int16, Int16) -> (Int16, Int16)

defLimit :: Int16 -> Integer

defaultBounds :: Int -> (Int16, Int16)

unsafeIndex :: Int -> Int16

isEmpty :: (Int16, Int16) -> Bool

inBounds :: (Int16, Int16) -> Int16 -> InBounds

isOverflow :: (Int16, Int16) -> Int16 -> Bool

isUnderflow :: (Int16, Int16) -> Int16 -> Bool

inRange :: (Int16, Int16) -> Int16 -> Bool

prev :: (Int16, Int16) -> Int16 -> Int16

next :: (Int16, Int16) -> Int16 -> Int16

offset :: (Int16, Int16) -> Int16 -> Int

index :: (Int16, Int16) -> Int -> Int16

range :: (Int16, Int16) -> [Int16]

subshape :: (Sub Int16 j, Index (Int16 :|: j)) => (Int16, Int16) -> (Int16 :|: j) -> (j, j)

slice :: (Sub Int16 j, ij ~ (Int16 :|: j), Index j) => (Int16, Int16) -> ij -> ((ij, ij), (j, j))

Index Int32

Defined in SDP.Index

Methods

size :: (Int32, Int32) -> Int

sizes :: (Int32, Int32) -> [Int]

safeElem :: (Int32, Int32) -> Int32 -> Int32

ordBounds :: (Int32, Int32) -> (Int32, Int32)

defLimit :: Int32 -> Integer

defaultBounds :: Int -> (Int32, Int32)

unsafeIndex :: Int -> Int32

isEmpty :: (Int32, Int32) -> Bool

inBounds :: (Int32, Int32) -> Int32 -> InBounds

isOverflow :: (Int32, Int32) -> Int32 -> Bool

isUnderflow :: (Int32, Int32) -> Int32 -> Bool

inRange :: (Int32, Int32) -> Int32 -> Bool

prev :: (Int32, Int32) -> Int32 -> Int32

next :: (Int32, Int32) -> Int32 -> Int32

offset :: (Int32, Int32) -> Int32 -> Int

index :: (Int32, Int32) -> Int -> Int32

range :: (Int32, Int32) -> [Int32]

subshape :: (Sub Int32 j, Index (Int32 :|: j)) => (Int32, Int32) -> (Int32 :|: j) -> (j, j)

slice :: (Sub Int32 j, ij ~ (Int32 :|: j), Index j) => (Int32, Int32) -> ij -> ((ij, ij), (j, j))

Index Int64

Defined in SDP.Index

Methods

size :: (Int64, Int64) -> Int

sizes :: (Int64, Int64) -> [Int]

safeElem :: (Int64, Int64) -> Int64 -> Int64

ordBounds :: (Int64, Int64) -> (Int64, Int64)

defLimit :: Int64 -> Integer

defaultBounds :: Int -> (Int64, Int64)

unsafeIndex :: Int -> Int64

isEmpty :: (Int64, Int64) -> Bool

inBounds :: (Int64, Int64) -> Int64 -> InBounds

isOverflow :: (Int64, Int64) -> Int64 -> Bool

isUnderflow :: (Int64, Int64) -> Int64 -> Bool

inRange :: (Int64, Int64) -> Int64 -> Bool

prev :: (Int64, Int64) -> Int64 -> Int64

next :: (Int64, Int64) -> Int64 -> Int64

offset :: (Int64, Int64) -> Int64 -> Int

index :: (Int64, Int64) -> Int -> Int64

range :: (Int64, Int64) -> [Int64]

subshape :: (Sub Int64 j, Index (Int64 :|: j)) => (Int64, Int64) -> (Int64 :|: j) -> (j, j)

slice :: (Sub Int64 j, ij ~ (Int64 :|: j), Index j) => (Int64, Int64) -> ij -> ((ij, ij), (j, j))

Index Integer

Note that Integer isn't Bounded, so it can't be used in multidimensional indices.

Defined in SDP.Index

Methods

size :: (Integer, Integer) -> Int

sizes :: (Integer, Integer) -> [Int]

safeElem :: (Integer, Integer) -> Integer -> Integer

ordBounds :: (Integer, Integer) -> (Integer, Integer)

defLimit :: Integer -> Integer

defaultBounds :: Int -> (Integer, Integer)

unsafeIndex :: Int -> Integer

isEmpty :: (Integer, Integer) -> Bool

inBounds :: (Integer, Integer) -> Integer -> InBounds

isOverflow :: (Integer, Integer) -> Integer -> Bool

isUnderflow :: (Integer, Integer) -> Integer -> Bool

inRange :: (Integer, Integer) -> Integer -> Bool

prev :: (Integer, Integer) -> Integer -> Integer

next :: (Integer, Integer) -> Integer -> Integer

offset :: (Integer, Integer) -> Integer -> Int

index :: (Integer, Integer) -> Int -> Integer

range :: (Integer, Integer) -> [Integer]

subshape :: (Sub Integer j, Index (Integer :|: j)) => (Integer, Integer) -> (Integer :|: j) -> (j, j)

slice :: (Sub Integer j, ij ~ (Integer :|: j), Index j) => (Integer, Integer) -> ij -> ((ij, ij), (j, j))

Index Word

Defined in SDP.Index

Methods

size :: (Word, Word) -> Int

sizes :: (Word, Word) -> [Int]

safeElem :: (Word, Word) -> Word -> Word

ordBounds :: (Word, Word) -> (Word, Word)

defLimit :: Word -> Integer

defaultBounds :: Int -> (Word, Word)

unsafeIndex :: Int -> Word

isEmpty :: (Word, Word) -> Bool

inBounds :: (Word, Word) -> Word -> InBounds

isOverflow :: (Word, Word) -> Word -> Bool

isUnderflow :: (Word, Word) -> Word -> Bool

inRange :: (Word, Word) -> Word -> Bool

prev :: (Word, Word) -> Word -> Word

next :: (Word, Word) -> Word -> Word

offset :: (Word, Word) -> Word -> Int

index :: (Word, Word) -> Int -> Word

range :: (Word, Word) -> [Word]

subshape :: (Sub Word j, Index (Word :|: j)) => (Word, Word) -> (Word :|: j) -> (j, j)

slice :: (Sub Word j, ij ~ (Word :|: j), Index j) => (Word, Word) -> ij -> ((ij, ij), (j, j))

Index Word8

Defined in SDP.Index

Methods

size :: (Word8, Word8) -> Int

sizes :: (Word8, Word8) -> [Int]

safeElem :: (Word8, Word8) -> Word8 -> Word8

ordBounds :: (Word8, Word8) -> (Word8, Word8)

defLimit :: Word8 -> Integer

defaultBounds :: Int -> (Word8, Word8)

unsafeIndex :: Int -> Word8

isEmpty :: (Word8, Word8) -> Bool

inBounds :: (Word8, Word8) -> Word8 -> InBounds

isOverflow :: (Word8, Word8) -> Word8 -> Bool

isUnderflow :: (Word8, Word8) -> Word8 -> Bool

inRange :: (Word8, Word8) -> Word8 -> Bool

prev :: (Word8, Word8) -> Word8 -> Word8

next :: (Word8, Word8) -> Word8 -> Word8

offset :: (Word8, Word8) -> Word8 -> Int

index :: (Word8, Word8) -> Int -> Word8

range :: (Word8, Word8) -> [Word8]

subshape :: (Sub Word8 j, Index (Word8 :|: j)) => (Word8, Word8) -> (Word8 :|: j) -> (j, j)

slice :: (Sub Word8 j, ij ~ (Word8 :|: j), Index j) => (Word8, Word8) -> ij -> ((ij, ij), (j, j))

Index Word16

Defined in SDP.Index

Methods

size :: (Word16, Word16) -> Int

sizes :: (Word16, Word16) -> [Int]

safeElem :: (Word16, Word16) -> Word16 -> Word16

ordBounds :: (Word16, Word16) -> (Word16, Word16)

defLimit :: Word16 -> Integer

defaultBounds :: Int -> (Word16, Word16)

unsafeIndex :: Int -> Word16

isEmpty :: (Word16, Word16) -> Bool

inBounds :: (Word16, Word16) -> Word16 -> InBounds

isOverflow :: (Word16, Word16) -> Word16 -> Bool

isUnderflow :: (Word16, Word16) -> Word16 -> Bool

inRange :: (Word16, Word16) -> Word16 -> Bool

prev :: (Word16, Word16) -> Word16 -> Word16

next :: (Word16, Word16) -> Word16 -> Word16

offset :: (Word16, Word16) -> Word16 -> Int

index :: (Word16, Word16) -> Int -> Word16

range :: (Word16, Word16) -> [Word16]

subshape :: (Sub Word16 j, Index (Word16 :|: j)) => (Word16, Word16) -> (Word16 :|: j) -> (j, j)

slice :: (Sub Word16 j, ij ~ (Word16 :|: j), Index j) => (Word16, Word16) -> ij -> ((ij, ij), (j, j))

Index Word32

Defined in SDP.Index

Methods

size :: (Word32, Word32) -> Int

sizes :: (Word32, Word32) -> [Int]

safeElem :: (Word32, Word32) -> Word32 -> Word32

ordBounds :: (Word32, Word32) -> (Word32, Word32)

defLimit :: Word32 -> Integer

defaultBounds :: Int -> (Word32, Word32)

unsafeIndex :: Int -> Word32

isEmpty :: (Word32, Word32) -> Bool

inBounds :: (Word32, Word32) -> Word32 -> InBounds

isOverflow :: (Word32, Word32) -> Word32 -> Bool

isUnderflow :: (Word32, Word32) -> Word32 -> Bool

inRange :: (Word32, Word32) -> Word32 -> Bool

prev :: (Word32, Word32) -> Word32 -> Word32

next :: (Word32, Word32) -> Word32 -> Word32

offset :: (Word32, Word32) -> Word32 -> Int

index :: (Word32, Word32) -> Int -> Word32

range :: (Word32, Word32) -> [Word32]

subshape :: (Sub Word32 j, Index (Word32 :|: j)) => (Word32, Word32) -> (Word32 :|: j) -> (j, j)

slice :: (Sub Word32 j, ij ~ (Word32 :|: j), Index j) => (Word32, Word32) -> ij -> ((ij, ij), (j, j))

Index Word64

Defined in SDP.Index

Methods

size :: (Word64, Word64) -> Int

sizes :: (Word64, Word64) -> [Int]

safeElem :: (Word64, Word64) -> Word64 -> Word64

ordBounds :: (Word64, Word64) -> (Word64, Word64)

defLimit :: Word64 -> Integer

defaultBounds :: Int -> (Word64, Word64)

unsafeIndex :: Int -> Word64

isEmpty :: (Word64, Word64) -> Bool

inBounds :: (Word64, Word64) -> Word64 -> InBounds

isOverflow :: (Word64, Word64) -> Word64 -> Bool

isUnderflow :: (Word64, Word64) -> Word64 -> Bool

inRange :: (Word64, Word64) -> Word64 -> Bool

prev :: (Word64, Word64) -> Word64 -> Word64

next :: (Word64, Word64) -> Word64 -> Word64

offset :: (Word64, Word64) -> Word64 -> Int

index :: (Word64, Word64) -> Int -> Word64

range :: (Word64, Word64) -> [Word64]

subshape :: (Sub Word64 j, Index (Word64 :|: j)) => (Word64, Word64) -> (Word64 :|: j) -> (j, j)

slice :: (Sub Word64 j, ij ~ (Word64 :|: j), Index j) => (Word64, Word64) -> ij -> ((ij, ij), (j, j))

Index ()

Defined in SDP.Index

Methods

size :: ((), ()) -> Int

sizes :: ((), ()) -> [Int]

safeElem :: ((), ()) -> () -> ()

ordBounds :: ((), ()) -> ((), ())

defLimit :: () -> Integer

defaultBounds :: Int -> ((), ())

unsafeIndex :: Int -> ()

isEmpty :: ((), ()) -> Bool

inBounds :: ((), ()) -> () -> InBounds

isOverflow :: ((), ()) -> () -> Bool

isUnderflow :: ((), ()) -> () -> Bool

inRange :: ((), ()) -> () -> Bool

prev :: ((), ()) -> () -> ()

next :: ((), ()) -> () -> ()

offset :: ((), ()) -> () -> Int

index :: ((), ()) -> Int -> ()

range :: ((), ()) -> [()]

subshape :: (Sub () j, Index (() :|: j)) => ((), ()) -> (() :|: j) -> (j, j)

slice :: (Sub () j, ij ~ (() :|: j), Index j) => ((), ()) -> ij -> ((ij, ij), (j, j))

Index CChar

Defined in SDP.Index

Methods

size :: (CChar, CChar) -> Int

sizes :: (CChar, CChar) -> [Int]

safeElem :: (CChar, CChar) -> CChar -> CChar

ordBounds :: (CChar, CChar) -> (CChar, CChar)

defLimit :: CChar -> Integer

defaultBounds :: Int -> (CChar, CChar)

unsafeIndex :: Int -> CChar

isEmpty :: (CChar, CChar) -> Bool

inBounds :: (CChar, CChar) -> CChar -> InBounds

isOverflow :: (CChar, CChar) -> CChar -> Bool

isUnderflow :: (CChar, CChar) -> CChar -> Bool

inRange :: (CChar, CChar) -> CChar -> Bool

prev :: (CChar, CChar) -> CChar -> CChar

next :: (CChar, CChar) -> CChar -> CChar

offset :: (CChar, CChar) -> CChar -> Int

index :: (CChar, CChar) -> Int -> CChar

range :: (CChar, CChar) -> [CChar]

subshape :: (Sub CChar j, Index (CChar :|: j)) => (CChar, CChar) -> (CChar :|: j) -> (j, j)

slice :: (Sub CChar j, ij ~ (CChar :|: j), Index j) => (CChar, CChar) -> ij -> ((ij, ij), (j, j))

Index CSChar

Defined in SDP.Index

Methods

size :: (CSChar, CSChar) -> Int

sizes :: (CSChar, CSChar) -> [Int]

safeElem :: (CSChar, CSChar) -> CSChar -> CSChar

ordBounds :: (CSChar, CSChar) -> (CSChar, CSChar)

defLimit :: CSChar -> Integer

defaultBounds :: Int -> (CSChar, CSChar)

unsafeIndex :: Int -> CSChar

isEmpty :: (CSChar, CSChar) -> Bool

inBounds :: (CSChar, CSChar) -> CSChar -> InBounds

isOverflow :: (CSChar, CSChar) -> CSChar -> Bool

isUnderflow :: (CSChar, CSChar) -> CSChar -> Bool

inRange :: (CSChar, CSChar) -> CSChar -> Bool

prev :: (CSChar, CSChar) -> CSChar -> CSChar

next :: (CSChar, CSChar) -> CSChar -> CSChar

offset :: (CSChar, CSChar) -> CSChar -> Int

index :: (CSChar, CSChar) -> Int -> CSChar

range :: (CSChar, CSChar) -> [CSChar]

subshape :: (Sub CSChar j, Index (CSChar :|: j)) => (CSChar, CSChar) -> (CSChar :|: j) -> (j, j)

slice :: (Sub CSChar j, ij ~ (CSChar :|: j), Index j) => (CSChar, CSChar) -> ij -> ((ij, ij), (j, j))

Index CUChar

Defined in SDP.Index

Methods

size :: (CUChar, CUChar) -> Int

sizes :: (CUChar, CUChar) -> [Int]

safeElem :: (CUChar, CUChar) -> CUChar -> CUChar

ordBounds :: (CUChar, CUChar) -> (CUChar, CUChar)

defLimit :: CUChar -> Integer

defaultBounds :: Int -> (CUChar, CUChar)

unsafeIndex :: Int -> CUChar

isEmpty :: (CUChar, CUChar) -> Bool

inBounds :: (CUChar, CUChar) -> CUChar -> InBounds

isOverflow :: (CUChar, CUChar) -> CUChar -> Bool

isUnderflow :: (CUChar, CUChar) -> CUChar -> Bool

inRange :: (CUChar, CUChar) -> CUChar -> Bool

prev :: (CUChar, CUChar) -> CUChar -> CUChar

next :: (CUChar, CUChar) -> CUChar -> CUChar

offset :: (CUChar, CUChar) -> CUChar -> Int

index :: (CUChar, CUChar) -> Int -> CUChar

range :: (CUChar, CUChar) -> [CUChar]

subshape :: (Sub CUChar j, Index (CUChar :|: j)) => (CUChar, CUChar) -> (CUChar :|: j) -> (j, j)

slice :: (Sub CUChar j, ij ~ (CUChar :|: j), Index j) => (CUChar, CUChar) -> ij -> ((ij, ij), (j, j))

Index CShort

Defined in SDP.Index

Methods

size :: (CShort, CShort) -> Int

sizes :: (CShort, CShort) -> [Int]

safeElem :: (CShort, CShort) -> CShort -> CShort

ordBounds :: (CShort, CShort) -> (CShort, CShort)

defLimit :: CShort -> Integer

defaultBounds :: Int -> (CShort, CShort)

unsafeIndex :: Int -> CShort

isEmpty :: (CShort, CShort) -> Bool

inBounds :: (CShort, CShort) -> CShort -> InBounds

isOverflow :: (CShort, CShort) -> CShort -> Bool

isUnderflow :: (CShort, CShort) -> CShort -> Bool

inRange :: (CShort, CShort) -> CShort -> Bool

prev :: (CShort, CShort) -> CShort -> CShort

next :: (CShort, CShort) -> CShort -> CShort

offset :: (CShort, CShort) -> CShort -> Int

index :: (CShort, CShort) -> Int -> CShort

range :: (CShort, CShort) -> [CShort]

subshape :: (Sub CShort j, Index (CShort :|: j)) => (CShort, CShort) -> (CShort :|: j) -> (j, j)

slice :: (Sub CShort j, ij ~ (CShort :|: j), Index j) => (CShort, CShort) -> ij -> ((ij, ij), (j, j))

Index CUShort

Defined in SDP.Index

Methods

size :: (CUShort, CUShort) -> Int

sizes :: (CUShort, CUShort) -> [Int]

safeElem :: (CUShort, CUShort) -> CUShort -> CUShort

ordBounds :: (CUShort, CUShort) -> (CUShort, CUShort)

defLimit :: CUShort -> Integer

defaultBounds :: Int -> (CUShort, CUShort)

unsafeIndex :: Int -> CUShort

isEmpty :: (CUShort, CUShort) -> Bool

inBounds :: (CUShort, CUShort) -> CUShort -> InBounds

isOverflow :: (CUShort, CUShort) -> CUShort -> Bool

isUnderflow :: (CUShort, CUShort) -> CUShort -> Bool

inRange :: (CUShort, CUShort) -> CUShort -> Bool

prev :: (CUShort, CUShort) -> CUShort -> CUShort

next :: (CUShort, CUShort) -> CUShort -> CUShort

offset :: (CUShort, CUShort) -> CUShort -> Int

index :: (CUShort, CUShort) -> Int -> CUShort

range :: (CUShort, CUShort) -> [CUShort]

subshape :: (Sub CUShort j, Index (CUShort :|: j)) => (CUShort, CUShort) -> (CUShort :|: j) -> (j, j)

slice :: (Sub CUShort j, ij ~ (CUShort :|: j), Index j) => (CUShort, CUShort) -> ij -> ((ij, ij), (j, j))

Index CInt

Defined in SDP.Index

Methods

size :: (CInt, CInt) -> Int

sizes :: (CInt, CInt) -> [Int]

safeElem :: (CInt, CInt) -> CInt -> CInt

ordBounds :: (CInt, CInt) -> (CInt, CInt)

defLimit :: CInt -> Integer

defaultBounds :: Int -> (CInt, CInt)

unsafeIndex :: Int -> CInt

isEmpty :: (CInt, CInt) -> Bool

inBounds :: (CInt, CInt) -> CInt -> InBounds

isOverflow :: (CInt, CInt) -> CInt -> Bool

isUnderflow :: (CInt, CInt) -> CInt -> Bool

inRange :: (CInt, CInt) -> CInt -> Bool

prev :: (CInt, CInt) -> CInt -> CInt

next :: (CInt, CInt) -> CInt -> CInt

offset :: (CInt, CInt) -> CInt -> Int

index :: (CInt, CInt) -> Int -> CInt

range :: (CInt, CInt) -> [CInt]

subshape :: (Sub CInt j, Index (CInt :|: j)) => (CInt, CInt) -> (CInt :|: j) -> (j, j)

slice :: (Sub CInt j, ij ~ (CInt :|: j), Index j) => (CInt, CInt) -> ij -> ((ij, ij), (j, j))

Index CUInt

Defined in SDP.Index

Methods

size :: (CUInt, CUInt) -> Int

sizes :: (CUInt, CUInt) -> [Int]

safeElem :: (CUInt, CUInt) -> CUInt -> CUInt

ordBounds :: (CUInt, CUInt) -> (CUInt, CUInt)

defLimit :: CUInt -> Integer

defaultBounds :: Int -> (CUInt, CUInt)

unsafeIndex :: Int -> CUInt

isEmpty :: (CUInt, CUInt) -> Bool

inBounds :: (CUInt, CUInt) -> CUInt -> InBounds

isOverflow :: (CUInt, CUInt) -> CUInt -> Bool

isUnderflow :: (CUInt, CUInt) -> CUInt -> Bool

inRange :: (CUInt, CUInt) -> CUInt -> Bool

prev :: (CUInt, CUInt) -> CUInt -> CUInt

next :: (CUInt, CUInt) -> CUInt -> CUInt

offset :: (CUInt, CUInt) -> CUInt -> Int

index :: (CUInt, CUInt) -> Int -> CUInt

range :: (CUInt, CUInt) -> [CUInt]

subshape :: (Sub CUInt j, Index (CUInt :|: j)) => (CUInt, CUInt) -> (CUInt :|: j) -> (j, j)

slice :: (Sub CUInt j, ij ~ (CUInt :|: j), Index j) => (CUInt, CUInt) -> ij -> ((ij, ij), (j, j))

Index CLong

Defined in SDP.Index

Methods

size :: (CLong, CLong) -> Int

sizes :: (CLong, CLong) -> [Int]

safeElem :: (CLong, CLong) -> CLong -> CLong

ordBounds :: (CLong, CLong) -> (CLong, CLong)

defLimit :: CLong -> Integer

defaultBounds :: Int -> (CLong, CLong)

unsafeIndex :: Int -> CLong

isEmpty :: (CLong, CLong) -> Bool

inBounds :: (CLong, CLong) -> CLong -> InBounds

isOverflow :: (CLong, CLong) -> CLong -> Bool

isUnderflow :: (CLong, CLong) -> CLong -> Bool

inRange :: (CLong, CLong) -> CLong -> Bool

prev :: (CLong, CLong) -> CLong -> CLong

next :: (CLong, CLong) -> CLong -> CLong

offset :: (CLong, CLong) -> CLong -> Int

index :: (CLong, CLong) -> Int -> CLong

range :: (CLong, CLong) -> [CLong]

subshape :: (Sub CLong j, Index (CLong :|: j)) => (CLong, CLong) -> (CLong :|: j) -> (j, j)

slice :: (Sub CLong j, ij ~ (CLong :|: j), Index j) => (CLong, CLong) -> ij -> ((ij, ij), (j, j))

Index CULong

Defined in SDP.Index

Methods

size :: (CULong, CULong) -> Int

sizes :: (CULong, CULong) -> [Int]

safeElem :: (CULong, CULong) -> CULong -> CULong

ordBounds :: (CULong, CULong) -> (CULong, CULong)

defLimit :: CULong -> Integer

defaultBounds :: Int -> (CULong, CULong)

unsafeIndex :: Int -> CULong

isEmpty :: (CULong, CULong) -> Bool

inBounds :: (CULong, CULong) -> CULong -> InBounds

isOverflow :: (CULong, CULong) -> CULong -> Bool

isUnderflow :: (CULong, CULong) -> CULong -> Bool

inRange :: (CULong, CULong) -> CULong -> Bool

prev :: (CULong, CULong) -> CULong -> CULong

next :: (CULong, CULong) -> CULong -> CULong

offset :: (CULong, CULong) -> CULong -> Int

index :: (CULong, CULong) -> Int -> CULong

range :: (CULong, CULong) -> [CULong]

subshape :: (Sub CULong j, Index (CULong :|: j)) => (CULong, CULong) -> (CULong :|: j) -> (j, j)

slice :: (Sub CULong j, ij ~ (CULong :|: j), Index j) => (CULong, CULong) -> ij -> ((ij, ij), (j, j))

Index CLLong

Defined in SDP.Index

Methods

size :: (CLLong, CLLong) -> Int

sizes :: (CLLong, CLLong) -> [Int]

safeElem :: (CLLong, CLLong) -> CLLong -> CLLong

ordBounds :: (CLLong, CLLong) -> (CLLong, CLLong)

defLimit :: CLLong -> Integer

defaultBounds :: Int -> (CLLong, CLLong)

unsafeIndex :: Int -> CLLong

isEmpty :: (CLLong, CLLong) -> Bool

inBounds :: (CLLong, CLLong) -> CLLong -> InBounds

isOverflow :: (CLLong, CLLong) -> CLLong -> Bool

isUnderflow :: (CLLong, CLLong) -> CLLong -> Bool

inRange :: (CLLong, CLLong) -> CLLong -> Bool

prev :: (CLLong, CLLong) -> CLLong -> CLLong

next :: (CLLong, CLLong) -> CLLong -> CLLong

offset :: (CLLong, CLLong) -> CLLong -> Int

index :: (CLLong, CLLong) -> Int -> CLLong

range :: (CLLong, CLLong) -> [CLLong]

subshape :: (Sub CLLong j, Index (CLLong :|: j)) => (CLLong, CLLong) -> (CLLong :|: j) -> (j, j)

slice :: (Sub CLLong j, ij ~ (CLLong :|: j), Index j) => (CLLong, CLLong) -> ij -> ((ij, ij), (j, j))

Index CULLong

Defined in SDP.Index

Methods

size :: (CULLong, CULLong) -> Int

sizes :: (CULLong, CULLong) -> [Int]

safeElem :: (CULLong, CULLong) -> CULLong -> CULLong

ordBounds :: (CULLong, CULLong) -> (CULLong, CULLong)

defLimit :: CULLong -> Integer

defaultBounds :: Int -> (CULLong, CULLong)

unsafeIndex :: Int -> CULLong

isEmpty :: (CULLong, CULLong) -> Bool

inBounds :: (CULLong, CULLong) -> CULLong -> InBounds

isOverflow :: (CULLong, CULLong) -> CULLong -> Bool

isUnderflow :: (CULLong, CULLong) -> CULLong -> Bool

inRange :: (CULLong, CULLong) -> CULLong -> Bool

prev :: (CULLong, CULLong) -> CULLong -> CULLong

next :: (CULLong, CULLong) -> CULLong -> CULLong

offset :: (CULLong, CULLong) -> CULLong -> Int

index :: (CULLong, CULLong) -> Int -> CULLong

range :: (CULLong, CULLong) -> [CULLong]

subshape :: (Sub CULLong j, Index (CULLong :|: j)) => (CULLong, CULLong) -> (CULLong :|: j) -> (j, j)

slice :: (Sub CULLong j, ij ~ (CULLong :|: j), Index j) => (CULLong, CULLong) -> ij -> ((ij, ij), (j, j))

Index CBool

Defined in SDP.Index

Methods

size :: (CBool, CBool) -> Int

sizes :: (CBool, CBool) -> [Int]

safeElem :: (CBool, CBool) -> CBool -> CBool

ordBounds :: (CBool, CBool) -> (CBool, CBool)

defLimit :: CBool -> Integer

defaultBounds :: Int -> (CBool, CBool)

unsafeIndex :: Int -> CBool

isEmpty :: (CBool, CBool) -> Bool

inBounds :: (CBool, CBool) -> CBool -> InBounds

isOverflow :: (CBool, CBool) -> CBool -> Bool

isUnderflow :: (CBool, CBool) -> CBool -> Bool

inRange :: (CBool, CBool) -> CBool -> Bool

prev :: (CBool, CBool) -> CBool -> CBool

next :: (CBool, CBool) -> CBool -> CBool

offset :: (CBool, CBool) -> CBool -> Int

index :: (CBool, CBool) -> Int -> CBool

range :: (CBool, CBool) -> [CBool]

subshape :: (Sub CBool j, Index (CBool :|: j)) => (CBool, CBool) -> (CBool :|: j) -> (j, j)

slice :: (Sub CBool j, ij ~ (CBool :|: j), Index j) => (CBool, CBool) -> ij -> ((ij, ij), (j, j))

Index CPtrdiff

Defined in SDP.Index

Methods

size :: (CPtrdiff, CPtrdiff) -> Int

sizes :: (CPtrdiff, CPtrdiff) -> [Int]

safeElem :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> CPtrdiff

ordBounds :: (CPtrdiff, CPtrdiff) -> (CPtrdiff, CPtrdiff)

defLimit :: CPtrdiff -> Integer

defaultBounds :: Int -> (CPtrdiff, CPtrdiff)

unsafeIndex :: Int -> CPtrdiff

isEmpty :: (CPtrdiff, CPtrdiff) -> Bool

inBounds :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> InBounds

isOverflow :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Bool

isUnderflow :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Bool

inRange :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Bool

prev :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> CPtrdiff

next :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> CPtrdiff

offset :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Int

index :: (CPtrdiff, CPtrdiff) -> Int -> CPtrdiff

range :: (CPtrdiff, CPtrdiff) -> [CPtrdiff]

subshape :: (Sub CPtrdiff j, Index (CPtrdiff :|: j)) => (CPtrdiff, CPtrdiff) -> (CPtrdiff :|: j) -> (j, j)

slice :: (Sub CPtrdiff j, ij ~ (CPtrdiff :|: j), Index j) => (CPtrdiff, CPtrdiff) -> ij -> ((ij, ij), (j, j))

Index CSize

Defined in SDP.Index

Methods

size :: (CSize, CSize) -> Int

sizes :: (CSize, CSize) -> [Int]

safeElem :: (CSize, CSize) -> CSize -> CSize

ordBounds :: (CSize, CSize) -> (CSize, CSize)

defLimit :: CSize -> Integer

defaultBounds :: Int -> (CSize, CSize)

unsafeIndex :: Int -> CSize

isEmpty :: (CSize, CSize) -> Bool

inBounds :: (CSize, CSize) -> CSize -> InBounds

isOverflow :: (CSize, CSize) -> CSize -> Bool

isUnderflow :: (CSize, CSize) -> CSize -> Bool

inRange :: (CSize, CSize) -> CSize -> Bool

prev :: (CSize, CSize) -> CSize -> CSize

next :: (CSize, CSize) -> CSize -> CSize

offset :: (CSize, CSize) -> CSize -> Int

index :: (CSize, CSize) -> Int -> CSize

range :: (CSize, CSize) -> [CSize]

subshape :: (Sub CSize j, Index (CSize :|: j)) => (CSize, CSize) -> (CSize :|: j) -> (j, j)

slice :: (Sub CSize j, ij ~ (CSize :|: j), Index j) => (CSize, CSize) -> ij -> ((ij, ij), (j, j))

Index CWchar

Defined in SDP.Index

Methods

size :: (CWchar, CWchar) -> Int

sizes :: (CWchar, CWchar) -> [Int]

safeElem :: (CWchar, CWchar) -> CWchar -> CWchar

ordBounds :: (CWchar, CWchar) -> (CWchar, CWchar)

defLimit :: CWchar -> Integer

defaultBounds :: Int -> (CWchar, CWchar)

unsafeIndex :: Int -> CWchar

isEmpty :: (CWchar, CWchar) -> Bool

inBounds :: (CWchar, CWchar) -> CWchar -> InBounds

isOverflow :: (CWchar, CWchar) -> CWchar -> Bool

isUnderflow :: (CWchar, CWchar) -> CWchar -> Bool

inRange :: (CWchar, CWchar) -> CWchar -> Bool

prev :: (CWchar, CWchar) -> CWchar -> CWchar

next :: (CWchar, CWchar) -> CWchar -> CWchar

offset :: (CWchar, CWchar) -> CWchar -> Int

index :: (CWchar, CWchar) -> Int -> CWchar

range :: (CWchar, CWchar) -> [CWchar]

subshape :: (Sub CWchar j, Index (CWchar :|: j)) => (CWchar, CWchar) -> (CWchar :|: j) -> (j, j)

slice :: (Sub CWchar j, ij ~ (CWchar :|: j), Index j) => (CWchar, CWchar) -> ij -> ((ij, ij), (j, j))

Index CSigAtomic

Defined in SDP.Index

Methods

size :: (CSigAtomic, CSigAtomic) -> Int

sizes :: (CSigAtomic, CSigAtomic) -> [Int]

safeElem :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> CSigAtomic

ordBounds :: (CSigAtomic, CSigAtomic) -> (CSigAtomic, CSigAtomic)

defLimit :: CSigAtomic -> Integer

defaultBounds :: Int -> (CSigAtomic, CSigAtomic)

unsafeIndex :: Int -> CSigAtomic

isEmpty :: (CSigAtomic, CSigAtomic) -> Bool

inBounds :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> InBounds

isOverflow :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Bool

isUnderflow :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Bool

inRange :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Bool

prev :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> CSigAtomic

next :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> CSigAtomic

offset :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Int

index :: (CSigAtomic, CSigAtomic) -> Int -> CSigAtomic

range :: (CSigAtomic, CSigAtomic) -> [CSigAtomic]

subshape :: (Sub CSigAtomic j, Index (CSigAtomic :|: j)) => (CSigAtomic, CSigAtomic) -> (CSigAtomic :|: j) -> (j, j)

slice :: (Sub CSigAtomic j, ij ~ (CSigAtomic :|: j), Index j) => (CSigAtomic, CSigAtomic) -> ij -> ((ij, ij), (j, j))

Index CIntPtr

Defined in SDP.Index

Methods

size :: (CIntPtr, CIntPtr) -> Int

sizes :: (CIntPtr, CIntPtr) -> [Int]

safeElem :: (CIntPtr, CIntPtr) -> CIntPtr -> CIntPtr

ordBounds :: (CIntPtr, CIntPtr) -> (CIntPtr, CIntPtr)

defLimit :: CIntPtr -> Integer

defaultBounds :: Int -> (CIntPtr, CIntPtr)

unsafeIndex :: Int -> CIntPtr

isEmpty :: (CIntPtr, CIntPtr) -> Bool

inBounds :: (CIntPtr, CIntPtr) -> CIntPtr -> InBounds

isOverflow :: (CIntPtr, CIntPtr) -> CIntPtr -> Bool

isUnderflow :: (CIntPtr, CIntPtr) -> CIntPtr -> Bool

inRange :: (CIntPtr, CIntPtr) -> CIntPtr -> Bool

prev :: (CIntPtr, CIntPtr) -> CIntPtr -> CIntPtr

next :: (CIntPtr, CIntPtr) -> CIntPtr -> CIntPtr

offset :: (CIntPtr, CIntPtr) -> CIntPtr -> Int

index :: (CIntPtr, CIntPtr) -> Int -> CIntPtr

range :: (CIntPtr, CIntPtr) -> [CIntPtr]

subshape :: (Sub CIntPtr j, Index (CIntPtr :|: j)) => (CIntPtr, CIntPtr) -> (CIntPtr :|: j) -> (j, j)

slice :: (Sub CIntPtr j, ij ~ (CIntPtr :|: j), Index j) => (CIntPtr, CIntPtr) -> ij -> ((ij, ij), (j, j))

Index CUIntPtr

Defined in SDP.Index

Methods

size :: (CUIntPtr, CUIntPtr) -> Int

sizes :: (CUIntPtr, CUIntPtr) -> [Int]

safeElem :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> CUIntPtr

ordBounds :: (CUIntPtr, CUIntPtr) -> (CUIntPtr, CUIntPtr)

defLimit :: CUIntPtr -> Integer

defaultBounds :: Int -> (CUIntPtr, CUIntPtr)

unsafeIndex :: Int -> CUIntPtr

isEmpty :: (CUIntPtr, CUIntPtr) -> Bool

inBounds :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> InBounds

isOverflow :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Bool

isUnderflow :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Bool

inRange :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Bool

prev :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> CUIntPtr

next :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> CUIntPtr

offset :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int

index :: (CUIntPtr, CUIntPtr) -> Int -> CUIntPtr

range :: (CUIntPtr, CUIntPtr) -> [CUIntPtr]

subshape :: (Sub CUIntPtr j, Index (CUIntPtr :|: j)) => (CUIntPtr, CUIntPtr) -> (CUIntPtr :|: j) -> (j, j)

slice :: (Sub CUIntPtr j, ij ~ (CUIntPtr :|: j), Index j) => (CUIntPtr, CUIntPtr) -> ij -> ((ij, ij), (j, j))

Index CIntMax

Defined in SDP.Index

Methods

size :: (CIntMax, CIntMax) -> Int

sizes :: (CIntMax, CIntMax) -> [Int]

safeElem :: (CIntMax, CIntMax) -> CIntMax -> CIntMax

ordBounds :: (CIntMax, CIntMax) -> (CIntMax, CIntMax)

defLimit :: CIntMax -> Integer

defaultBounds :: Int -> (CIntMax, CIntMax)

unsafeIndex :: Int -> CIntMax

isEmpty :: (CIntMax, CIntMax) -> Bool

inBounds :: (CIntMax, CIntMax) -> CIntMax -> InBounds

isOverflow :: (CIntMax, CIntMax) -> CIntMax -> Bool

isUnderflow :: (CIntMax, CIntMax) -> CIntMax -> Bool

inRange :: (CIntMax, CIntMax) -> CIntMax -> Bool

prev :: (CIntMax, CIntMax) -> CIntMax -> CIntMax

next :: (CIntMax, CIntMax) -> CIntMax -> CIntMax

offset :: (CIntMax, CIntMax) -> CIntMax -> Int

index :: (CIntMax, CIntMax) -> Int -> CIntMax

range :: (CIntMax, CIntMax) -> [CIntMax]

subshape :: (Sub CIntMax j, Index (CIntMax :|: j)) => (CIntMax, CIntMax) -> (CIntMax :|: j) -> (j, j)

slice :: (Sub CIntMax j, ij ~ (CIntMax :|: j), Index j) => (CIntMax, CIntMax) -> ij -> ((ij, ij), (j, j))

Index CUIntMax

Defined in SDP.Index

Methods

size :: (CUIntMax, CUIntMax) -> Int

sizes :: (CUIntMax, CUIntMax) -> [Int]

safeElem :: (CUIntMax, CUIntMax) -> CUIntMax -> CUIntMax

ordBounds :: (CUIntMax, CUIntMax) -> (CUIntMax, CUIntMax)

defLimit :: CUIntMax -> Integer

defaultBounds :: Int -> (CUIntMax, CUIntMax)

unsafeIndex :: Int -> CUIntMax

isEmpty :: (CUIntMax, CUIntMax) -> Bool

inBounds :: (CUIntMax, CUIntMax) -> CUIntMax -> InBounds

isOverflow :: (CUIntMax, CUIntMax) -> CUIntMax -> Bool

isUnderflow :: (CUIntMax, CUIntMax) -> CUIntMax -> Bool

inRange :: (CUIntMax, CUIntMax) -> CUIntMax -> Bool

prev :: (CUIntMax, CUIntMax) -> CUIntMax -> CUIntMax

next :: (CUIntMax, CUIntMax) -> CUIntMax -> CUIntMax

offset :: (CUIntMax, CUIntMax) -> CUIntMax -> Int

index :: (CUIntMax, CUIntMax) -> Int -> CUIntMax

range :: (CUIntMax, CUIntMax) -> [CUIntMax]

subshape :: (Sub CUIntMax j, Index (CUIntMax :|: j)) => (CUIntMax, CUIntMax) -> (CUIntMax :|: j) -> (j, j)

slice :: (Sub CUIntMax j, ij ~ (CUIntMax :|: j), Index j) => (CUIntMax, CUIntMax) -> ij -> ((ij, ij), (j, j))

Index E

Defined in SDP.Index

Methods

size :: (E, E) -> Int

sizes :: (E, E) -> [Int]

safeElem :: (E, E) -> E -> E

ordBounds :: (E, E) -> (E, E)

defLimit :: E -> Integer

defaultBounds :: Int -> (E, E)

unsafeIndex :: Int -> E

isEmpty :: (E, E) -> Bool

inBounds :: (E, E) -> E -> InBounds

isOverflow :: (E, E) -> E -> Bool

isUnderflow :: (E, E) -> E -> Bool

inRange :: (E, E) -> E -> Bool

prev :: (E, E) -> E -> E

next :: (E, E) -> E -> E

offset :: (E, E) -> E -> Int

index :: (E, E) -> Int -> E

range :: (E, E) -> [E]

subshape :: (Sub E j, Index (E :|: j)) => (E, E) -> (E :|: j) -> (j, j)

slice :: (Sub E j, ij ~ (E :|: j), Index j) => (E, E) -> ij -> ((ij, ij), (j, j))

Index IntAs64

Defined in SDP.Unboxed.IntAs

Methods

size :: (IntAs64, IntAs64) -> Int

sizes :: (IntAs64, IntAs64) -> [Int]

safeElem :: (IntAs64, IntAs64) -> IntAs64 -> IntAs64

ordBounds :: (IntAs64, IntAs64) -> (IntAs64, IntAs64)

defLimit :: IntAs64 -> Integer

defaultBounds :: Int -> (IntAs64, IntAs64)

unsafeIndex :: Int -> IntAs64

isEmpty :: (IntAs64, IntAs64) -> Bool

inBounds :: (IntAs64, IntAs64) -> IntAs64 -> InBounds

isOverflow :: (IntAs64, IntAs64) -> IntAs64 -> Bool

isUnderflow :: (IntAs64, IntAs64) -> IntAs64 -> Bool

inRange :: (IntAs64, IntAs64) -> IntAs64 -> Bool

prev :: (IntAs64, IntAs64) -> IntAs64 -> IntAs64

next :: (IntAs64, IntAs64) -> IntAs64 -> IntAs64

offset :: (IntAs64, IntAs64) -> IntAs64 -> Int

index :: (IntAs64, IntAs64) -> Int -> IntAs64

range :: (IntAs64, IntAs64) -> [IntAs64]

subshape :: (Sub IntAs64 j, Index (IntAs64 :|: j)) => (IntAs64, IntAs64) -> (IntAs64 :|: j) -> (j, j)

slice :: (Sub IntAs64 j, ij ~ (IntAs64 :|: j), Index j) => (IntAs64, IntAs64) -> ij -> ((ij, ij), (j, j))

Index IntAs32

Defined in SDP.Unboxed.IntAs

Methods

size :: (IntAs32, IntAs32) -> Int

sizes :: (IntAs32, IntAs32) -> [Int]

safeElem :: (IntAs32, IntAs32) -> IntAs32 -> IntAs32

ordBounds :: (IntAs32, IntAs32) -> (IntAs32, IntAs32)

defLimit :: IntAs32 -> Integer

defaultBounds :: Int -> (IntAs32, IntAs32)

unsafeIndex :: Int -> IntAs32

isEmpty :: (IntAs32, IntAs32) -> Bool

inBounds :: (IntAs32, IntAs32) -> IntAs32 -> InBounds

isOverflow :: (IntAs32, IntAs32) -> IntAs32 -> Bool

isUnderflow :: (IntAs32, IntAs32) -> IntAs32 -> Bool

inRange :: (IntAs32, IntAs32) -> IntAs32 -> Bool

prev :: (IntAs32, IntAs32) -> IntAs32 -> IntAs32

next :: (IntAs32, IntAs32) -> IntAs32 -> IntAs32

offset :: (IntAs32, IntAs32) -> IntAs32 -> Int

index :: (IntAs32, IntAs32) -> Int -> IntAs32

range :: (IntAs32, IntAs32) -> [IntAs32]

subshape :: (Sub IntAs32 j, Index (IntAs32 :|: j)) => (IntAs32, IntAs32) -> (IntAs32 :|: j) -> (j, j)

slice :: (Sub IntAs32 j, ij ~ (IntAs32 :|: j), Index j) => (IntAs32, IntAs32) -> ij -> ((ij, ij), (j, j))

Index IntAs16

Defined in SDP.Unboxed.IntAs

Methods

size :: (IntAs16, IntAs16) -> Int

sizes :: (IntAs16, IntAs16) -> [Int]

safeElem :: (IntAs16, IntAs16) -> IntAs16 -> IntAs16

ordBounds :: (IntAs16, IntAs16) -> (IntAs16, IntAs16)

defLimit :: IntAs16 -> Integer

defaultBounds :: Int -> (IntAs16, IntAs16)

unsafeIndex :: Int -> IntAs16

isEmpty :: (IntAs16, IntAs16) -> Bool

inBounds :: (IntAs16, IntAs16) -> IntAs16 -> InBounds

isOverflow :: (IntAs16, IntAs16) -> IntAs16 -> Bool

isUnderflow :: (IntAs16, IntAs16) -> IntAs16 -> Bool

inRange :: (IntAs16, IntAs16) -> IntAs16 -> Bool

prev :: (IntAs16, IntAs16) -> IntAs16 -> IntAs16

next :: (IntAs16, IntAs16) -> IntAs16 -> IntAs16

offset :: (IntAs16, IntAs16) -> IntAs16 -> Int

index :: (IntAs16, IntAs16) -> Int -> IntAs16

range :: (IntAs16, IntAs16) -> [IntAs16]

subshape :: (Sub IntAs16 j, Index (IntAs16 :|: j)) => (IntAs16, IntAs16) -> (IntAs16 :|: j) -> (j, j)

slice :: (Sub IntAs16 j, ij ~ (IntAs16 :|: j), Index j) => (IntAs16, IntAs16) -> ij -> ((ij, ij), (j, j))

Index IntAs8

Defined in SDP.Unboxed.IntAs

Methods

size :: (IntAs8, IntAs8) -> Int

sizes :: (IntAs8, IntAs8) -> [Int]

safeElem :: (IntAs8, IntAs8) -> IntAs8 -> IntAs8

ordBounds :: (IntAs8, IntAs8) -> (IntAs8, IntAs8)

defLimit :: IntAs8 -> Integer

defaultBounds :: Int -> (IntAs8, IntAs8)

unsafeIndex :: Int -> IntAs8

isEmpty :: (IntAs8, IntAs8) -> Bool

inBounds :: (IntAs8, IntAs8) -> IntAs8 -> InBounds

isOverflow :: (IntAs8, IntAs8) -> IntAs8 -> Bool

isUnderflow :: (IntAs8, IntAs8) -> IntAs8 -> Bool

inRange :: (IntAs8, IntAs8) -> IntAs8 -> Bool

prev :: (IntAs8, IntAs8) -> IntAs8 -> IntAs8

next :: (IntAs8, IntAs8) -> IntAs8 -> IntAs8

offset :: (IntAs8, IntAs8) -> IntAs8 -> Int

index :: (IntAs8, IntAs8) -> Int -> IntAs8

range :: (IntAs8, IntAs8) -> [IntAs8]

subshape :: (Sub IntAs8 j, Index (IntAs8 :|: j)) => (IntAs8, IntAs8) -> (IntAs8 :|: j) -> (j, j)

slice :: (Sub IntAs8 j, ij ~ (IntAs8 :|: j), Index j) => (IntAs8, IntAs8) -> ij -> ((ij, ij), (j, j))

Index WordAs64

Defined in SDP.Unboxed.WordAs

Methods

size :: (WordAs64, WordAs64) -> Int

sizes :: (WordAs64, WordAs64) -> [Int]

safeElem :: (WordAs64, WordAs64) -> WordAs64 -> WordAs64

ordBounds :: (WordAs64, WordAs64) -> (WordAs64, WordAs64)

defLimit :: WordAs64 -> Integer

defaultBounds :: Int -> (WordAs64, WordAs64)

unsafeIndex :: Int -> WordAs64

isEmpty :: (WordAs64, WordAs64) -> Bool

inBounds :: (WordAs64, WordAs64) -> WordAs64 -> InBounds

isOverflow :: (WordAs64, WordAs64) -> WordAs64 -> Bool

isUnderflow :: (WordAs64, WordAs64) -> WordAs64 -> Bool

inRange :: (WordAs64, WordAs64) -> WordAs64 -> Bool

prev :: (WordAs64, WordAs64) -> WordAs64 -> WordAs64

next :: (WordAs64, WordAs64) -> WordAs64 -> WordAs64

offset :: (WordAs64, WordAs64) -> WordAs64 -> Int

index :: (WordAs64, WordAs64) -> Int -> WordAs64

range :: (WordAs64, WordAs64) -> [WordAs64]

subshape :: (Sub WordAs64 j, Index (WordAs64 :|: j)) => (WordAs64, WordAs64) -> (WordAs64 :|: j) -> (j, j)

slice :: (Sub WordAs64 j, ij ~ (WordAs64 :|: j), Index j) => (WordAs64, WordAs64) -> ij -> ((ij, ij), (j, j))

Index WordAs32

Defined in SDP.Unboxed.WordAs

Methods

size :: (WordAs32, WordAs32) -> Int

sizes :: (WordAs32, WordAs32) -> [Int]

safeElem :: (WordAs32, WordAs32) -> WordAs32 -> WordAs32

ordBounds :: (WordAs32, WordAs32) -> (WordAs32, WordAs32)

defLimit :: WordAs32 -> Integer

defaultBounds :: Int -> (WordAs32, WordAs32)

unsafeIndex :: Int -> WordAs32

isEmpty :: (WordAs32, WordAs32) -> Bool

inBounds :: (WordAs32, WordAs32) -> WordAs32 -> InBounds

isOverflow :: (WordAs32, WordAs32) -> WordAs32 -> Bool

isUnderflow :: (WordAs32, WordAs32) -> WordAs32 -> Bool

inRange :: (WordAs32, WordAs32) -> WordAs32 -> Bool

prev :: (WordAs32, WordAs32) -> WordAs32 -> WordAs32

next :: (WordAs32, WordAs32) -> WordAs32 -> WordAs32

offset :: (WordAs32, WordAs32) -> WordAs32 -> Int

index :: (WordAs32, WordAs32) -> Int -> WordAs32

range :: (WordAs32, WordAs32) -> [WordAs32]

subshape :: (Sub WordAs32 j, Index (WordAs32 :|: j)) => (WordAs32, WordAs32) -> (WordAs32 :|: j) -> (j, j)

slice :: (Sub WordAs32 j, ij ~ (WordAs32 :|: j), Index j) => (WordAs32, WordAs32) -> ij -> ((ij, ij), (j, j))

Index WordAs16

Defined in SDP.Unboxed.WordAs

Methods

size :: (WordAs16, WordAs16) -> Int

sizes :: (WordAs16, WordAs16) -> [Int]

safeElem :: (WordAs16, WordAs16) -> WordAs16 -> WordAs16

ordBounds :: (WordAs16, WordAs16) -> (WordAs16, WordAs16)

defLimit :: WordAs16 -> Integer

defaultBounds :: Int -> (WordAs16, WordAs16)

unsafeIndex :: Int -> WordAs16

isEmpty :: (WordAs16, WordAs16) -> Bool

inBounds :: (WordAs16, WordAs16) -> WordAs16 -> InBounds

isOverflow :: (WordAs16, WordAs16) -> WordAs16 -> Bool

isUnderflow :: (WordAs16, WordAs16) -> WordAs16 -> Bool

inRange :: (WordAs16, WordAs16) -> WordAs16 -> Bool

prev :: (WordAs16, WordAs16) -> WordAs16 -> WordAs16

next :: (WordAs16, WordAs16) -> WordAs16 -> WordAs16

offset :: (WordAs16, WordAs16) -> WordAs16 -> Int

index :: (WordAs16, WordAs16) -> Int -> WordAs16

range :: (WordAs16, WordAs16) -> [WordAs16]

subshape :: (Sub WordAs16 j, Index (WordAs16 :|: j)) => (WordAs16, WordAs16) -> (WordAs16 :|: j) -> (j, j)

slice :: (Sub WordAs16 j, ij ~ (WordAs16 :|: j), Index j) => (WordAs16, WordAs16) -> ij -> ((ij, ij), (j, j))

Index WordAs8

Defined in SDP.Unboxed.WordAs

Methods

size :: (WordAs8, WordAs8) -> Int

sizes :: (WordAs8, WordAs8) -> [Int]

safeElem :: (WordAs8, WordAs8) -> WordAs8 -> WordAs8

ordBounds :: (WordAs8, WordAs8) -> (WordAs8, WordAs8)

defLimit :: WordAs8 -> Integer

defaultBounds :: Int -> (WordAs8, WordAs8)

unsafeIndex :: Int -> WordAs8

isEmpty :: (WordAs8, WordAs8) -> Bool

inBounds :: (WordAs8, WordAs8) -> WordAs8 -> InBounds

isOverflow :: (WordAs8, WordAs8) -> WordAs8 -> Bool

isUnderflow :: (WordAs8, WordAs8) -> WordAs8 -> Bool

inRange :: (WordAs8, WordAs8) -> WordAs8 -> Bool

prev :: (WordAs8, WordAs8) -> WordAs8 -> WordAs8

next :: (WordAs8, WordAs8) -> WordAs8 -> WordAs8

offset :: (WordAs8, WordAs8) -> WordAs8 -> Int

index :: (WordAs8, WordAs8) -> Int -> WordAs8

range :: (WordAs8, WordAs8) -> [WordAs8]

subshape :: (Sub WordAs8 j, Index (WordAs8 :|: j)) => (WordAs8, WordAs8) -> (WordAs8 :|: j) -> (j, j)

slice :: (Sub WordAs8 j, ij ~ (WordAs8 :|: j), Index j) => (WordAs8, WordAs8) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T15 i)

Defined in SDP.Index

Methods

size :: (T15 i, T15 i) -> Int

sizes :: (T15 i, T15 i) -> [Int]

safeElem :: (T15 i, T15 i) -> T15 i -> T15 i

ordBounds :: (T15 i, T15 i) -> (T15 i, T15 i)

defLimit :: T15 i -> Integer

defaultBounds :: Int -> (T15 i, T15 i)

unsafeIndex :: Int -> T15 i

isEmpty :: (T15 i, T15 i) -> Bool

inBounds :: (T15 i, T15 i) -> T15 i -> InBounds

isOverflow :: (T15 i, T15 i) -> T15 i -> Bool

isUnderflow :: (T15 i, T15 i) -> T15 i -> Bool

inRange :: (T15 i, T15 i) -> T15 i -> Bool

prev :: (T15 i, T15 i) -> T15 i -> T15 i

next :: (T15 i, T15 i) -> T15 i -> T15 i

offset :: (T15 i, T15 i) -> T15 i -> Int

index :: (T15 i, T15 i) -> Int -> T15 i

range :: (T15 i, T15 i) -> [T15 i]

subshape :: (Sub (T15 i) j, Index (T15 i :|: j)) => (T15 i, T15 i) -> (T15 i :|: j) -> (j, j)

slice :: (Sub (T15 i) j, ij ~ (T15 i :|: j), Index j) => (T15 i, T15 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T14 i)

Defined in SDP.Index

Methods

size :: (T14 i, T14 i) -> Int

sizes :: (T14 i, T14 i) -> [Int]

safeElem :: (T14 i, T14 i) -> T14 i -> T14 i

ordBounds :: (T14 i, T14 i) -> (T14 i, T14 i)

defLimit :: T14 i -> Integer

defaultBounds :: Int -> (T14 i, T14 i)

unsafeIndex :: Int -> T14 i

isEmpty :: (T14 i, T14 i) -> Bool

inBounds :: (T14 i, T14 i) -> T14 i -> InBounds

isOverflow :: (T14 i, T14 i) -> T14 i -> Bool

isUnderflow :: (T14 i, T14 i) -> T14 i -> Bool

inRange :: (T14 i, T14 i) -> T14 i -> Bool

prev :: (T14 i, T14 i) -> T14 i -> T14 i

next :: (T14 i, T14 i) -> T14 i -> T14 i

offset :: (T14 i, T14 i) -> T14 i -> Int

index :: (T14 i, T14 i) -> Int -> T14 i

range :: (T14 i, T14 i) -> [T14 i]

subshape :: (Sub (T14 i) j, Index (T14 i :|: j)) => (T14 i, T14 i) -> (T14 i :|: j) -> (j, j)

slice :: (Sub (T14 i) j, ij ~ (T14 i :|: j), Index j) => (T14 i, T14 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T13 i)

Defined in SDP.Index

Methods

size :: (T13 i, T13 i) -> Int

sizes :: (T13 i, T13 i) -> [Int]

safeElem :: (T13 i, T13 i) -> T13 i -> T13 i

ordBounds :: (T13 i, T13 i) -> (T13 i, T13 i)

defLimit :: T13 i -> Integer

defaultBounds :: Int -> (T13 i, T13 i)

unsafeIndex :: Int -> T13 i

isEmpty :: (T13 i, T13 i) -> Bool

inBounds :: (T13 i, T13 i) -> T13 i -> InBounds

isOverflow :: (T13 i, T13 i) -> T13 i -> Bool

isUnderflow :: (T13 i, T13 i) -> T13 i -> Bool

inRange :: (T13 i, T13 i) -> T13 i -> Bool

prev :: (T13 i, T13 i) -> T13 i -> T13 i

next :: (T13 i, T13 i) -> T13 i -> T13 i

offset :: (T13 i, T13 i) -> T13 i -> Int

index :: (T13 i, T13 i) -> Int -> T13 i

range :: (T13 i, T13 i) -> [T13 i]

subshape :: (Sub (T13 i) j, Index (T13 i :|: j)) => (T13 i, T13 i) -> (T13 i :|: j) -> (j, j)

slice :: (Sub (T13 i) j, ij ~ (T13 i :|: j), Index j) => (T13 i, T13 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T12 i)

Defined in SDP.Index

Methods

size :: (T12 i, T12 i) -> Int

sizes :: (T12 i, T12 i) -> [Int]

safeElem :: (T12 i, T12 i) -> T12 i -> T12 i

ordBounds :: (T12 i, T12 i) -> (T12 i, T12 i)

defLimit :: T12 i -> Integer

defaultBounds :: Int -> (T12 i, T12 i)

unsafeIndex :: Int -> T12 i

isEmpty :: (T12 i, T12 i) -> Bool

inBounds :: (T12 i, T12 i) -> T12 i -> InBounds

isOverflow :: (T12 i, T12 i) -> T12 i -> Bool

isUnderflow :: (T12 i, T12 i) -> T12 i -> Bool

inRange :: (T12 i, T12 i) -> T12 i -> Bool

prev :: (T12 i, T12 i) -> T12 i -> T12 i

next :: (T12 i, T12 i) -> T12 i -> T12 i

offset :: (T12 i, T12 i) -> T12 i -> Int

index :: (T12 i, T12 i) -> Int -> T12 i

range :: (T12 i, T12 i) -> [T12 i]

subshape :: (Sub (T12 i) j, Index (T12 i :|: j)) => (T12 i, T12 i) -> (T12 i :|: j) -> (j, j)

slice :: (Sub (T12 i) j, ij ~ (T12 i :|: j), Index j) => (T12 i, T12 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T11 i)

Defined in SDP.Index

Methods

size :: (T11 i, T11 i) -> Int

sizes :: (T11 i, T11 i) -> [Int]

safeElem :: (T11 i, T11 i) -> T11 i -> T11 i

ordBounds :: (T11 i, T11 i) -> (T11 i, T11 i)

defLimit :: T11 i -> Integer

defaultBounds :: Int -> (T11 i, T11 i)

unsafeIndex :: Int -> T11 i

isEmpty :: (T11 i, T11 i) -> Bool

inBounds :: (T11 i, T11 i) -> T11 i -> InBounds

isOverflow :: (T11 i, T11 i) -> T11 i -> Bool

isUnderflow :: (T11 i, T11 i) -> T11 i -> Bool

inRange :: (T11 i, T11 i) -> T11 i -> Bool

prev :: (T11 i, T11 i) -> T11 i -> T11 i

next :: (T11 i, T11 i) -> T11 i -> T11 i

offset :: (T11 i, T11 i) -> T11 i -> Int

index :: (T11 i, T11 i) -> Int -> T11 i

range :: (T11 i, T11 i) -> [T11 i]

subshape :: (Sub (T11 i) j, Index (T11 i :|: j)) => (T11 i, T11 i) -> (T11 i :|: j) -> (j, j)

slice :: (Sub (T11 i) j, ij ~ (T11 i :|: j), Index j) => (T11 i, T11 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T10 i)

Defined in SDP.Index

Methods

size :: (T10 i, T10 i) -> Int

sizes :: (T10 i, T10 i) -> [Int]

safeElem :: (T10 i, T10 i) -> T10 i -> T10 i

ordBounds :: (T10 i, T10 i) -> (T10 i, T10 i)

defLimit :: T10 i -> Integer

defaultBounds :: Int -> (T10 i, T10 i)

unsafeIndex :: Int -> T10 i

isEmpty :: (T10 i, T10 i) -> Bool

inBounds :: (T10 i, T10 i) -> T10 i -> InBounds

isOverflow :: (T10 i, T10 i) -> T10 i -> Bool

isUnderflow :: (T10 i, T10 i) -> T10 i -> Bool

inRange :: (T10 i, T10 i) -> T10 i -> Bool

prev :: (T10 i, T10 i) -> T10 i -> T10 i

next :: (T10 i, T10 i) -> T10 i -> T10 i

offset :: (T10 i, T10 i) -> T10 i -> Int

index :: (T10 i, T10 i) -> Int -> T10 i

range :: (T10 i, T10 i) -> [T10 i]

subshape :: (Sub (T10 i) j, Index (T10 i :|: j)) => (T10 i, T10 i) -> (T10 i :|: j) -> (j, j)

slice :: (Sub (T10 i) j, ij ~ (T10 i :|: j), Index j) => (T10 i, T10 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T9 i)

Defined in SDP.Index

Methods

size :: (T9 i, T9 i) -> Int

sizes :: (T9 i, T9 i) -> [Int]

safeElem :: (T9 i, T9 i) -> T9 i -> T9 i

ordBounds :: (T9 i, T9 i) -> (T9 i, T9 i)

defLimit :: T9 i -> Integer

defaultBounds :: Int -> (T9 i, T9 i)

unsafeIndex :: Int -> T9 i

isEmpty :: (T9 i, T9 i) -> Bool

inBounds :: (T9 i, T9 i) -> T9 i -> InBounds

isOverflow :: (T9 i, T9 i) -> T9 i -> Bool

isUnderflow :: (T9 i, T9 i) -> T9 i -> Bool

inRange :: (T9 i, T9 i) -> T9 i -> Bool

prev :: (T9 i, T9 i) -> T9 i -> T9 i

next :: (T9 i, T9 i) -> T9 i -> T9 i

offset :: (T9 i, T9 i) -> T9 i -> Int

index :: (T9 i, T9 i) -> Int -> T9 i

range :: (T9 i, T9 i) -> [T9 i]

subshape :: (Sub (T9 i) j, Index (T9 i :|: j)) => (T9 i, T9 i) -> (T9 i :|: j) -> (j, j)

slice :: (Sub (T9 i) j, ij ~ (T9 i :|: j), Index j) => (T9 i, T9 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T8 i)

Defined in SDP.Index

Methods

size :: (T8 i, T8 i) -> Int

sizes :: (T8 i, T8 i) -> [Int]

safeElem :: (T8 i, T8 i) -> T8 i -> T8 i

ordBounds :: (T8 i, T8 i) -> (T8 i, T8 i)

defLimit :: T8 i -> Integer

defaultBounds :: Int -> (T8 i, T8 i)

unsafeIndex :: Int -> T8 i

isEmpty :: (T8 i, T8 i) -> Bool

inBounds :: (T8 i, T8 i) -> T8 i -> InBounds

isOverflow :: (T8 i, T8 i) -> T8 i -> Bool

isUnderflow :: (T8 i, T8 i) -> T8 i -> Bool

inRange :: (T8 i, T8 i) -> T8 i -> Bool

prev :: (T8 i, T8 i) -> T8 i -> T8 i

next :: (T8 i, T8 i) -> T8 i -> T8 i

offset :: (T8 i, T8 i) -> T8 i -> Int

index :: (T8 i, T8 i) -> Int -> T8 i

range :: (T8 i, T8 i) -> [T8 i]

subshape :: (Sub (T8 i) j, Index (T8 i :|: j)) => (T8 i, T8 i) -> (T8 i :|: j) -> (j, j)

slice :: (Sub (T8 i) j, ij ~ (T8 i :|: j), Index j) => (T8 i, T8 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T7 i)

Defined in SDP.Index

Methods

size :: (T7 i, T7 i) -> Int

sizes :: (T7 i, T7 i) -> [Int]

safeElem :: (T7 i, T7 i) -> T7 i -> T7 i

ordBounds :: (T7 i, T7 i) -> (T7 i, T7 i)

defLimit :: T7 i -> Integer

defaultBounds :: Int -> (T7 i, T7 i)

unsafeIndex :: Int -> T7 i

isEmpty :: (T7 i, T7 i) -> Bool

inBounds :: (T7 i, T7 i) -> T7 i -> InBounds

isOverflow :: (T7 i, T7 i) -> T7 i -> Bool

isUnderflow :: (T7 i, T7 i) -> T7 i -> Bool

inRange :: (T7 i, T7 i) -> T7 i -> Bool

prev :: (T7 i, T7 i) -> T7 i -> T7 i

next :: (T7 i, T7 i) -> T7 i -> T7 i

offset :: (T7 i, T7 i) -> T7 i -> Int

index :: (T7 i, T7 i) -> Int -> T7 i

range :: (T7 i, T7 i) -> [T7 i]

subshape :: (Sub (T7 i) j, Index (T7 i :|: j)) => (T7 i, T7 i) -> (T7 i :|: j) -> (j, j)

slice :: (Sub (T7 i) j, ij ~ (T7 i :|: j), Index j) => (T7 i, T7 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T6 i)

Defined in SDP.Index

Methods

size :: (T6 i, T6 i) -> Int

sizes :: (T6 i, T6 i) -> [Int]

safeElem :: (T6 i, T6 i) -> T6 i -> T6 i

ordBounds :: (T6 i, T6 i) -> (T6 i, T6 i)

defLimit :: T6 i -> Integer

defaultBounds :: Int -> (T6 i, T6 i)

unsafeIndex :: Int -> T6 i

isEmpty :: (T6 i, T6 i) -> Bool

inBounds :: (T6 i, T6 i) -> T6 i -> InBounds

isOverflow :: (T6 i, T6 i) -> T6 i -> Bool

isUnderflow :: (T6 i, T6 i) -> T6 i -> Bool

inRange :: (T6 i, T6 i) -> T6 i -> Bool

prev :: (T6 i, T6 i) -> T6 i -> T6 i

next :: (T6 i, T6 i) -> T6 i -> T6 i

offset :: (T6 i, T6 i) -> T6 i -> Int

index :: (T6 i, T6 i) -> Int -> T6 i

range :: (T6 i, T6 i) -> [T6 i]

subshape :: (Sub (T6 i) j, Index (T6 i :|: j)) => (T6 i, T6 i) -> (T6 i :|: j) -> (j, j)

slice :: (Sub (T6 i) j, ij ~ (T6 i :|: j), Index j) => (T6 i, T6 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T5 i)

Defined in SDP.Index

Methods

size :: (T5 i, T5 i) -> Int

sizes :: (T5 i, T5 i) -> [Int]

safeElem :: (T5 i, T5 i) -> T5 i -> T5 i

ordBounds :: (T5 i, T5 i) -> (T5 i, T5 i)

defLimit :: T5 i -> Integer

defaultBounds :: Int -> (T5 i, T5 i)

unsafeIndex :: Int -> T5 i

isEmpty :: (T5 i, T5 i) -> Bool

inBounds :: (T5 i, T5 i) -> T5 i -> InBounds

isOverflow :: (T5 i, T5 i) -> T5 i -> Bool

isUnderflow :: (T5 i, T5 i) -> T5 i -> Bool

inRange :: (T5 i, T5 i) -> T5 i -> Bool

prev :: (T5 i, T5 i) -> T5 i -> T5 i

next :: (T5 i, T5 i) -> T5 i -> T5 i

offset :: (T5 i, T5 i) -> T5 i -> Int

index :: (T5 i, T5 i) -> Int -> T5 i

range :: (T5 i, T5 i) -> [T5 i]

subshape :: (Sub (T5 i) j, Index (T5 i :|: j)) => (T5 i, T5 i) -> (T5 i :|: j) -> (j, j)

slice :: (Sub (T5 i) j, ij ~ (T5 i :|: j), Index j) => (T5 i, T5 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T4 i)

Defined in SDP.Index

Methods

size :: (T4 i, T4 i) -> Int

sizes :: (T4 i, T4 i) -> [Int]

safeElem :: (T4 i, T4 i) -> T4 i -> T4 i

ordBounds :: (T4 i, T4 i) -> (T4 i, T4 i)

defLimit :: T4 i -> Integer

defaultBounds :: Int -> (T4 i, T4 i)

unsafeIndex :: Int -> T4 i

isEmpty :: (T4 i, T4 i) -> Bool

inBounds :: (T4 i, T4 i) -> T4 i -> InBounds

isOverflow :: (T4 i, T4 i) -> T4 i -> Bool

isUnderflow :: (T4 i, T4 i) -> T4 i -> Bool

inRange :: (T4 i, T4 i) -> T4 i -> Bool

prev :: (T4 i, T4 i) -> T4 i -> T4 i

next :: (T4 i, T4 i) -> T4 i -> T4 i

offset :: (T4 i, T4 i) -> T4 i -> Int

index :: (T4 i, T4 i) -> Int -> T4 i

range :: (T4 i, T4 i) -> [T4 i]

subshape :: (Sub (T4 i) j, Index (T4 i :|: j)) => (T4 i, T4 i) -> (T4 i :|: j) -> (j, j)

slice :: (Sub (T4 i) j, ij ~ (T4 i :|: j), Index j) => (T4 i, T4 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T3 i)

Defined in SDP.Index

Methods

size :: (T3 i, T3 i) -> Int

sizes :: (T3 i, T3 i) -> [Int]

safeElem :: (T3 i, T3 i) -> T3 i -> T3 i

ordBounds :: (T3 i, T3 i) -> (T3 i, T3 i)

defLimit :: T3 i -> Integer

defaultBounds :: Int -> (T3 i, T3 i)

unsafeIndex :: Int -> T3 i

isEmpty :: (T3 i, T3 i) -> Bool

inBounds :: (T3 i, T3 i) -> T3 i -> InBounds

isOverflow :: (T3 i, T3 i) -> T3 i -> Bool

isUnderflow :: (T3 i, T3 i) -> T3 i -> Bool

inRange :: (T3 i, T3 i) -> T3 i -> Bool

prev :: (T3 i, T3 i) -> T3 i -> T3 i

next :: (T3 i, T3 i) -> T3 i -> T3 i

offset :: (T3 i, T3 i) -> T3 i -> Int

index :: (T3 i, T3 i) -> Int -> T3 i

range :: (T3 i, T3 i) -> [T3 i]

subshape :: (Sub (T3 i) j, Index (T3 i :|: j)) => (T3 i, T3 i) -> (T3 i :|: j) -> (j, j)

slice :: (Sub (T3 i) j, ij ~ (T3 i :|: j), Index j) => (T3 i, T3 i) -> ij -> ((ij, ij), (j, j))

(Ord i, Index i, Enum i, Bounded i) => Index (T2 i)

Defined in SDP.Index

Methods

size :: (T2 i, T2 i) -> Int

sizes :: (T2 i, T2 i) -> [Int]

safeElem :: (T2 i, T2 i) -> T2 i -> T2 i

ordBounds :: (T2 i, T2 i) -> (T2 i, T2 i)

defLimit :: T2 i -> Integer

defaultBounds :: Int -> (T2 i, T2 i)

unsafeIndex :: Int -> T2 i

isEmpty :: (T2 i, T2 i) -> Bool

inBounds :: (T2 i, T2 i) -> T2 i -> InBounds

isOverflow :: (T2 i, T2 i) -> T2 i -> Bool

isUnderflow :: (T2 i, T2 i) -> T2 i -> Bool

inRange :: (T2 i, T2 i) -> T2 i -> Bool

prev :: (T2 i, T2 i) -> T2 i -> T2 i

next :: (T2 i, T2 i) -> T2 i -> T2 i

offset :: (T2 i, T2 i) -> T2 i -> Int

index :: (T2 i, T2 i) -> Int -> T2 i

range :: (T2 i, T2 i) -> [T2 i]

subshape :: (Sub (T2 i) j, Index (T2 i :|: j)) => (T2 i, T2 i) -> (T2 i :|: j) -> (j, j)

slice :: (Sub (T2 i) j, ij ~ (T2 i :|: j), Index j) => (T2 i, T2 i) -> ij -> ((ij, ij), (j, j))

(Index i, Enum i, Bounded i, Index (i' :& i)) => Index ((i' :& i) :& i)

Defined in SDP.Index

Methods

size :: ((i' :& i) :& i, (i' :& i) :& i) -> Int

sizes :: ((i' :& i) :& i, (i' :& i) :& i) -> [Int]

safeElem :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> (i' :& i) :& i

ordBounds :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i, (i' :& i) :& i)

defLimit :: ((i' :& i) :& i) -> Integer

defaultBounds :: Int -> ((i' :& i) :& i, (i' :& i) :& i)

unsafeIndex :: Int -> (i' :& i) :& i

isEmpty :: ((i' :& i) :& i, (i' :& i) :& i) -> Bool

inBounds :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> InBounds

isOverflow :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> Bool

isUnderflow :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> Bool

inRange :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> Bool

prev :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> (i' :& i) :& i

next :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> (i' :& i) :& i

offset :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> Int

index :: ((i' :& i) :& i, (i' :& i) :& i) -> Int -> (i' :& i) :& i

range :: ((i' :& i) :& i, (i' :& i) :& i) -> [(i' :& i) :& i]

subshape :: (Sub ((i' :& i) :& i) j, Index (((i' :& i) :& i) :|: j)) => ((i' :& i) :& i, (i' :& i) :& i) -> (((i' :& i) :& i) :|: j) -> (j, j)

slice :: (Sub ((i' :& i) :& i) j, ij ~ (((i' :& i) :& i) :|: j), Index j) => ((i' :& i) :& i, (i' :& i) :& i) -> ij -> ((ij, ij), (j, j))

Index i => Index (E :& i)

Defined in SDP.Index

Methods

size :: (E :& i, E :& i) -> Int

sizes :: (E :& i, E :& i) -> [Int]

safeElem :: (E :& i, E :& i) -> (E :& i) -> E :& i

ordBounds :: (E :& i, E :& i) -> (E :& i, E :& i)

defLimit :: (E :& i) -> Integer

defaultBounds :: Int -> (E :& i, E :& i)

unsafeIndex :: Int -> E :& i

isEmpty :: (E :& i, E :& i) -> Bool

inBounds :: (E :& i, E :& i) -> (E :& i) -> InBounds

isOverflow :: (E :& i, E :& i) -> (E :& i) -> Bool

isUnderflow :: (E :& i, E :& i) -> (E :& i) -> Bool

inRange :: (E :& i, E :& i) -> (E :& i) -> Bool

prev :: (E :& i, E :& i) -> (E :& i) -> E :& i

next :: (E :& i, E :& i) -> (E :& i) -> E :& i

offset :: (E :& i, E :& i) -> (E :& i) -> Int

index :: (E :& i, E :& i) -> Int -> E :& i

range :: (E :& i, E :& i) -> [E :& i]

subshape :: (Sub (E :& i) j, Index ((E :& i) :|: j)) => (E :& i, E :& i) -> ((E :& i) :|: j) -> (j, j)

slice :: (Sub (E :& i) j, ij ~ ((E :& i) :|: j), Index j) => (E :& i, E :& i) -> ij -> ((ij, ij), (j, j))

Helpers

data InBounds

InBounds - service type that specifies index and bounds status.

Constructors

ER

Empty range

UR

Underflow range

IN

Index in range

OR

Overflow range

Instances

Enum InBounds

Defined in SDP.Index

Methods

succ :: InBounds -> InBounds

pred :: InBounds -> InBounds

toEnum :: Int -> InBounds

fromEnum :: InBounds -> Int

enumFrom :: InBounds -> [InBounds]

enumFromThen :: InBounds -> InBounds -> [InBounds]

enumFromTo :: InBounds -> InBounds -> [InBounds]

enumFromThenTo :: InBounds -> InBounds -> InBounds -> [InBounds]

Eq InBounds

Defined in SDP.Index

Methods

(==) :: InBounds -> InBounds -> Bool

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

Read InBounds

Defined in SDP.Index

Methods

readsPrec :: Int -> ReadS InBounds

readList :: ReadS [InBounds]

readPrec :: ReadPrec InBounds

readListPrec :: ReadPrec [InBounds]

Show InBounds

Defined in SDP.Index

Methods

showsPrec :: Int -> InBounds -> ShowS

show :: InBounds -> String

showList :: [InBounds] -> ShowS

offsetIntegral :: (Index i, Integral i) => (i, i) -> i -> Int

Default offset for Integral types.

defaultBoundsUnsign :: (Index i, Bounded i) => Int -> (i, i)

Default defaultBounds for unsigned types.

Orphan instances

Index i => Estimate (i, i)

Methods

(<.=>) :: (i, i) -> Int -> Ordering

(<==>) :: Compare (i, i)

(.==) :: (i, i) -> Int -> Bool

(./=) :: (i, i) -> Int -> Bool

(.<=) :: (i, i) -> Int -> Bool

(.>=) :: (i, i) -> Int -> Bool

(.<) :: (i, i) -> Int -> Bool

(.>) :: (i, i) -> Int -> Bool

(.<.) :: (i, i) -> (i, i) -> Bool

(.>.) :: (i, i) -> (i, i) -> Bool

(.<=.) :: (i, i) -> (i, i) -> Bool

(.>=.) :: (i, i) -> (i, i) -> Bool

(.==.) :: (i, i) -> (i, i) -> Bool

(./=.) :: (i, i) -> (i, i) -> Bool

Index i => Nullable (i, i)

Methods

lzero :: (i, i)

isNull :: (i, i) -> Bool