sdp-0.2: Simple Data Processing
Copyright (c) Andrey Mulik 2019 BSD-style work.a.mulik@gmail.com non-portable (GHC extensions) Trustworthy Haskell2010

SDP.Index

Description

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

Synopsis

# Shapes

module SDP.Shape

type family i :|: j where ... Source #

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

Equations

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

type SubIndex = Sub Source #

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 Source #

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 Source #

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 Source #

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

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 Source #

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 Source #

Returns the size of range.

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

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

Returns the sizes of range dimensionwise.

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

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

Returns the index belonging to the given range.

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

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

defLimit :: i -> Integer Source #

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

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

defaultBounds :: Int -> (i, i) Source #

Returns default range by size.

unsafeIndex :: Int -> i Source #

Returns index by offset in default range.

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

isEmpty :: (i, i) -> Bool Source #

Checks if the bounds is empty.

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

Checks the index status in bounds.

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

Checks if the index is overflow.

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

Checks if the index is underflow.

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

Checks if the index is in range.

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

Returns previous index in range.

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

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

Returns next index in range.

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

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

Returns offset (indent) of index in range.

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

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

Returns index by this offset (indent) in range.

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

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

Returns the ordered list of indices in this range.

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

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

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

#### Instances

Instances details
 Source # Instance detailsDefined in SDP.Index Methodssize :: (Char, Char) -> Int Source #sizes :: (Char, Char) -> [Int] Source #safeElem :: (Char, Char) -> Char -> Char Source #ordBounds :: (Char, Char) -> (Char, Char) Source #defaultBounds :: Int -> (Char, Char) Source #isEmpty :: (Char, Char) -> Bool Source #inBounds :: (Char, Char) -> Char -> InBounds Source #isOverflow :: (Char, Char) -> Char -> Bool Source #isUnderflow :: (Char, Char) -> Char -> Bool Source #inRange :: (Char, Char) -> Char -> Bool Source #prev :: (Char, Char) -> Char -> Char Source #next :: (Char, Char) -> Char -> Char Source #offset :: (Char, Char) -> Char -> Int Source #index :: (Char, Char) -> Int -> Char Source #range :: (Char, Char) -> [Char] Source #subshape :: (Sub Char j, Index (Char :|: j)) => (Char, Char) -> (Char :|: j) -> (j, j) Source #slice :: (Sub Char j, ij ~ (Char :|: j), Index j) => (Char, Char) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Int, Int) -> Int Source #sizes :: (Int, Int) -> [Int] Source #safeElem :: (Int, Int) -> Int -> Int Source #ordBounds :: (Int, Int) -> (Int, Int) Source #defaultBounds :: Int -> (Int, Int) Source #isEmpty :: (Int, Int) -> Bool Source #inBounds :: (Int, Int) -> Int -> InBounds Source #isOverflow :: (Int, Int) -> Int -> Bool Source #isUnderflow :: (Int, Int) -> Int -> Bool Source #inRange :: (Int, Int) -> Int -> Bool Source #prev :: (Int, Int) -> Int -> Int Source #next :: (Int, Int) -> Int -> Int Source #offset :: (Int, Int) -> Int -> Int Source #index :: (Int, Int) -> Int -> Int Source #range :: (Int, Int) -> [Int] Source #subshape :: (Sub Int j, Index (Int :|: j)) => (Int, Int) -> (Int :|: j) -> (j, j) Source #slice :: (Sub Int j, ij ~ (Int :|: j), Index j) => (Int, Int) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Int8, Int8) -> Int Source #sizes :: (Int8, Int8) -> [Int] Source #safeElem :: (Int8, Int8) -> Int8 -> Int8 Source #ordBounds :: (Int8, Int8) -> (Int8, Int8) Source #defaultBounds :: Int -> (Int8, Int8) Source #isEmpty :: (Int8, Int8) -> Bool Source #inBounds :: (Int8, Int8) -> Int8 -> InBounds Source #isOverflow :: (Int8, Int8) -> Int8 -> Bool Source #isUnderflow :: (Int8, Int8) -> Int8 -> Bool Source #inRange :: (Int8, Int8) -> Int8 -> Bool Source #prev :: (Int8, Int8) -> Int8 -> Int8 Source #next :: (Int8, Int8) -> Int8 -> Int8 Source #offset :: (Int8, Int8) -> Int8 -> Int Source #index :: (Int8, Int8) -> Int -> Int8 Source #range :: (Int8, Int8) -> [Int8] Source #subshape :: (Sub Int8 j, Index (Int8 :|: j)) => (Int8, Int8) -> (Int8 :|: j) -> (j, j) Source #slice :: (Sub Int8 j, ij ~ (Int8 :|: j), Index j) => (Int8, Int8) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Int16, Int16) -> Int Source #sizes :: (Int16, Int16) -> [Int] Source #safeElem :: (Int16, Int16) -> Int16 -> Int16 Source #ordBounds :: (Int16, Int16) -> (Int16, Int16) Source #isEmpty :: (Int16, Int16) -> Bool Source #inBounds :: (Int16, Int16) -> Int16 -> InBounds Source #isOverflow :: (Int16, Int16) -> Int16 -> Bool Source #isUnderflow :: (Int16, Int16) -> Int16 -> Bool Source #inRange :: (Int16, Int16) -> Int16 -> Bool Source #prev :: (Int16, Int16) -> Int16 -> Int16 Source #next :: (Int16, Int16) -> Int16 -> Int16 Source #offset :: (Int16, Int16) -> Int16 -> Int Source #index :: (Int16, Int16) -> Int -> Int16 Source #range :: (Int16, Int16) -> [Int16] Source #subshape :: (Sub Int16 j, Index (Int16 :|: j)) => (Int16, Int16) -> (Int16 :|: j) -> (j, j) Source #slice :: (Sub Int16 j, ij ~ (Int16 :|: j), Index j) => (Int16, Int16) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Int32, Int32) -> Int Source #sizes :: (Int32, Int32) -> [Int] Source #safeElem :: (Int32, Int32) -> Int32 -> Int32 Source #ordBounds :: (Int32, Int32) -> (Int32, Int32) Source #isEmpty :: (Int32, Int32) -> Bool Source #inBounds :: (Int32, Int32) -> Int32 -> InBounds Source #isOverflow :: (Int32, Int32) -> Int32 -> Bool Source #isUnderflow :: (Int32, Int32) -> Int32 -> Bool Source #inRange :: (Int32, Int32) -> Int32 -> Bool Source #prev :: (Int32, Int32) -> Int32 -> Int32 Source #next :: (Int32, Int32) -> Int32 -> Int32 Source #offset :: (Int32, Int32) -> Int32 -> Int Source #index :: (Int32, Int32) -> Int -> Int32 Source #range :: (Int32, Int32) -> [Int32] Source #subshape :: (Sub Int32 j, Index (Int32 :|: j)) => (Int32, Int32) -> (Int32 :|: j) -> (j, j) Source #slice :: (Sub Int32 j, ij ~ (Int32 :|: j), Index j) => (Int32, Int32) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Int64, Int64) -> Int Source #sizes :: (Int64, Int64) -> [Int] Source #safeElem :: (Int64, Int64) -> Int64 -> Int64 Source #ordBounds :: (Int64, Int64) -> (Int64, Int64) Source #isEmpty :: (Int64, Int64) -> Bool Source #inBounds :: (Int64, Int64) -> Int64 -> InBounds Source #isOverflow :: (Int64, Int64) -> Int64 -> Bool Source #isUnderflow :: (Int64, Int64) -> Int64 -> Bool Source #inRange :: (Int64, Int64) -> Int64 -> Bool Source #prev :: (Int64, Int64) -> Int64 -> Int64 Source #next :: (Int64, Int64) -> Int64 -> Int64 Source #offset :: (Int64, Int64) -> Int64 -> Int Source #index :: (Int64, Int64) -> Int -> Int64 Source #range :: (Int64, Int64) -> [Int64] Source #subshape :: (Sub Int64 j, Index (Int64 :|: j)) => (Int64, Int64) -> (Int64 :|: j) -> (j, j) Source #slice :: (Sub Int64 j, ij ~ (Int64 :|: j), Index j) => (Int64, Int64) -> ij -> ((ij, ij), (j, j)) Source # Source # Note that Integer isn't Bounded, so it can't be used in multidimensional indices. Instance detailsDefined in SDP.Index Methodssize :: (Integer, Integer) -> Int Source #sizes :: (Integer, Integer) -> [Int] Source #safeElem :: (Integer, Integer) -> Integer -> Integer Source #ordBounds :: (Integer, Integer) -> (Integer, Integer) Source #isEmpty :: (Integer, Integer) -> Bool Source #inBounds :: (Integer, Integer) -> Integer -> InBounds Source #isOverflow :: (Integer, Integer) -> Integer -> Bool Source #isUnderflow :: (Integer, Integer) -> Integer -> Bool Source #inRange :: (Integer, Integer) -> Integer -> Bool Source #prev :: (Integer, Integer) -> Integer -> Integer Source #next :: (Integer, Integer) -> Integer -> Integer Source #offset :: (Integer, Integer) -> Integer -> Int Source #index :: (Integer, Integer) -> Int -> Integer Source #range :: (Integer, Integer) -> [Integer] Source #subshape :: (Sub Integer j, Index (Integer :|: j)) => (Integer, Integer) -> (Integer :|: j) -> (j, j) Source #slice :: (Sub Integer j, ij ~ (Integer :|: j), Index j) => (Integer, Integer) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Word, Word) -> Int Source #sizes :: (Word, Word) -> [Int] Source #safeElem :: (Word, Word) -> Word -> Word Source #ordBounds :: (Word, Word) -> (Word, Word) Source #defaultBounds :: Int -> (Word, Word) Source #isEmpty :: (Word, Word) -> Bool Source #inBounds :: (Word, Word) -> Word -> InBounds Source #isOverflow :: (Word, Word) -> Word -> Bool Source #isUnderflow :: (Word, Word) -> Word -> Bool Source #inRange :: (Word, Word) -> Word -> Bool Source #prev :: (Word, Word) -> Word -> Word Source #next :: (Word, Word) -> Word -> Word Source #offset :: (Word, Word) -> Word -> Int Source #index :: (Word, Word) -> Int -> Word Source #range :: (Word, Word) -> [Word] Source #subshape :: (Sub Word j, Index (Word :|: j)) => (Word, Word) -> (Word :|: j) -> (j, j) Source #slice :: (Sub Word j, ij ~ (Word :|: j), Index j) => (Word, Word) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Word8, Word8) -> Int Source #sizes :: (Word8, Word8) -> [Int] Source #safeElem :: (Word8, Word8) -> Word8 -> Word8 Source #ordBounds :: (Word8, Word8) -> (Word8, Word8) Source #isEmpty :: (Word8, Word8) -> Bool Source #inBounds :: (Word8, Word8) -> Word8 -> InBounds Source #isOverflow :: (Word8, Word8) -> Word8 -> Bool Source #isUnderflow :: (Word8, Word8) -> Word8 -> Bool Source #inRange :: (Word8, Word8) -> Word8 -> Bool Source #prev :: (Word8, Word8) -> Word8 -> Word8 Source #next :: (Word8, Word8) -> Word8 -> Word8 Source #offset :: (Word8, Word8) -> Word8 -> Int Source #index :: (Word8, Word8) -> Int -> Word8 Source #range :: (Word8, Word8) -> [Word8] Source #subshape :: (Sub Word8 j, Index (Word8 :|: j)) => (Word8, Word8) -> (Word8 :|: j) -> (j, j) Source #slice :: (Sub Word8 j, ij ~ (Word8 :|: j), Index j) => (Word8, Word8) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Word16, Word16) -> Int Source #sizes :: (Word16, Word16) -> [Int] Source #safeElem :: (Word16, Word16) -> Word16 -> Word16 Source #ordBounds :: (Word16, Word16) -> (Word16, Word16) Source #isEmpty :: (Word16, Word16) -> Bool Source #inBounds :: (Word16, Word16) -> Word16 -> InBounds Source #isOverflow :: (Word16, Word16) -> Word16 -> Bool Source #isUnderflow :: (Word16, Word16) -> Word16 -> Bool Source #inRange :: (Word16, Word16) -> Word16 -> Bool Source #prev :: (Word16, Word16) -> Word16 -> Word16 Source #next :: (Word16, Word16) -> Word16 -> Word16 Source #offset :: (Word16, Word16) -> Word16 -> Int Source #index :: (Word16, Word16) -> Int -> Word16 Source #range :: (Word16, Word16) -> [Word16] Source #subshape :: (Sub Word16 j, Index (Word16 :|: j)) => (Word16, Word16) -> (Word16 :|: j) -> (j, j) Source #slice :: (Sub Word16 j, ij ~ (Word16 :|: j), Index j) => (Word16, Word16) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Word32, Word32) -> Int Source #sizes :: (Word32, Word32) -> [Int] Source #safeElem :: (Word32, Word32) -> Word32 -> Word32 Source #ordBounds :: (Word32, Word32) -> (Word32, Word32) Source #isEmpty :: (Word32, Word32) -> Bool Source #inBounds :: (Word32, Word32) -> Word32 -> InBounds Source #isOverflow :: (Word32, Word32) -> Word32 -> Bool Source #isUnderflow :: (Word32, Word32) -> Word32 -> Bool Source #inRange :: (Word32, Word32) -> Word32 -> Bool Source #prev :: (Word32, Word32) -> Word32 -> Word32 Source #next :: (Word32, Word32) -> Word32 -> Word32 Source #offset :: (Word32, Word32) -> Word32 -> Int Source #index :: (Word32, Word32) -> Int -> Word32 Source #range :: (Word32, Word32) -> [Word32] Source #subshape :: (Sub Word32 j, Index (Word32 :|: j)) => (Word32, Word32) -> (Word32 :|: j) -> (j, j) Source #slice :: (Sub Word32 j, ij ~ (Word32 :|: j), Index j) => (Word32, Word32) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (Word64, Word64) -> Int Source #sizes :: (Word64, Word64) -> [Int] Source #safeElem :: (Word64, Word64) -> Word64 -> Word64 Source #ordBounds :: (Word64, Word64) -> (Word64, Word64) Source #isEmpty :: (Word64, Word64) -> Bool Source #inBounds :: (Word64, Word64) -> Word64 -> InBounds Source #isOverflow :: (Word64, Word64) -> Word64 -> Bool Source #isUnderflow :: (Word64, Word64) -> Word64 -> Bool Source #inRange :: (Word64, Word64) -> Word64 -> Bool Source #prev :: (Word64, Word64) -> Word64 -> Word64 Source #next :: (Word64, Word64) -> Word64 -> Word64 Source #offset :: (Word64, Word64) -> Word64 -> Int Source #index :: (Word64, Word64) -> Int -> Word64 Source #range :: (Word64, Word64) -> [Word64] Source #subshape :: (Sub Word64 j, Index (Word64 :|: j)) => (Word64, Word64) -> (Word64 :|: j) -> (j, j) Source #slice :: (Sub Word64 j, ij ~ (Word64 :|: j), Index j) => (Word64, Word64) -> ij -> ((ij, ij), (j, j)) Source # Index () Source # Instance detailsDefined in SDP.Index Methodssize :: ((), ()) -> Int Source #sizes :: ((), ()) -> [Int] Source #safeElem :: ((), ()) -> () -> () Source #ordBounds :: ((), ()) -> ((), ()) Source #defLimit :: () -> Integer Source #defaultBounds :: Int -> ((), ()) Source #unsafeIndex :: Int -> () Source #isEmpty :: ((), ()) -> Bool Source #inBounds :: ((), ()) -> () -> InBounds Source #isOverflow :: ((), ()) -> () -> Bool Source #isUnderflow :: ((), ()) -> () -> Bool Source #inRange :: ((), ()) -> () -> Bool Source #prev :: ((), ()) -> () -> () Source #next :: ((), ()) -> () -> () Source #offset :: ((), ()) -> () -> Int Source #index :: ((), ()) -> Int -> () Source #range :: ((), ()) -> [()] Source #subshape :: (Sub () j, Index (() :|: j)) => ((), ()) -> (() :|: j) -> (j, j) Source #slice :: (Sub () j, ij ~ (() :|: j), Index j) => ((), ()) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CChar, CChar) -> Int Source #sizes :: (CChar, CChar) -> [Int] Source #safeElem :: (CChar, CChar) -> CChar -> CChar Source #ordBounds :: (CChar, CChar) -> (CChar, CChar) Source #isEmpty :: (CChar, CChar) -> Bool Source #inBounds :: (CChar, CChar) -> CChar -> InBounds Source #isOverflow :: (CChar, CChar) -> CChar -> Bool Source #isUnderflow :: (CChar, CChar) -> CChar -> Bool Source #inRange :: (CChar, CChar) -> CChar -> Bool Source #prev :: (CChar, CChar) -> CChar -> CChar Source #next :: (CChar, CChar) -> CChar -> CChar Source #offset :: (CChar, CChar) -> CChar -> Int Source #index :: (CChar, CChar) -> Int -> CChar Source #range :: (CChar, CChar) -> [CChar] Source #subshape :: (Sub CChar j, Index (CChar :|: j)) => (CChar, CChar) -> (CChar :|: j) -> (j, j) Source #slice :: (Sub CChar j, ij ~ (CChar :|: j), Index j) => (CChar, CChar) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CSChar, CSChar) -> Int Source #sizes :: (CSChar, CSChar) -> [Int] Source #safeElem :: (CSChar, CSChar) -> CSChar -> CSChar Source #ordBounds :: (CSChar, CSChar) -> (CSChar, CSChar) Source #isEmpty :: (CSChar, CSChar) -> Bool Source #inBounds :: (CSChar, CSChar) -> CSChar -> InBounds Source #isOverflow :: (CSChar, CSChar) -> CSChar -> Bool Source #isUnderflow :: (CSChar, CSChar) -> CSChar -> Bool Source #inRange :: (CSChar, CSChar) -> CSChar -> Bool Source #prev :: (CSChar, CSChar) -> CSChar -> CSChar Source #next :: (CSChar, CSChar) -> CSChar -> CSChar Source #offset :: (CSChar, CSChar) -> CSChar -> Int Source #index :: (CSChar, CSChar) -> Int -> CSChar Source #range :: (CSChar, CSChar) -> [CSChar] Source #subshape :: (Sub CSChar j, Index (CSChar :|: j)) => (CSChar, CSChar) -> (CSChar :|: j) -> (j, j) Source #slice :: (Sub CSChar j, ij ~ (CSChar :|: j), Index j) => (CSChar, CSChar) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CUChar, CUChar) -> Int Source #sizes :: (CUChar, CUChar) -> [Int] Source #safeElem :: (CUChar, CUChar) -> CUChar -> CUChar Source #ordBounds :: (CUChar, CUChar) -> (CUChar, CUChar) Source #isEmpty :: (CUChar, CUChar) -> Bool Source #inBounds :: (CUChar, CUChar) -> CUChar -> InBounds Source #isOverflow :: (CUChar, CUChar) -> CUChar -> Bool Source #isUnderflow :: (CUChar, CUChar) -> CUChar -> Bool Source #inRange :: (CUChar, CUChar) -> CUChar -> Bool Source #prev :: (CUChar, CUChar) -> CUChar -> CUChar Source #next :: (CUChar, CUChar) -> CUChar -> CUChar Source #offset :: (CUChar, CUChar) -> CUChar -> Int Source #index :: (CUChar, CUChar) -> Int -> CUChar Source #range :: (CUChar, CUChar) -> [CUChar] Source #subshape :: (Sub CUChar j, Index (CUChar :|: j)) => (CUChar, CUChar) -> (CUChar :|: j) -> (j, j) Source #slice :: (Sub CUChar j, ij ~ (CUChar :|: j), Index j) => (CUChar, CUChar) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CShort, CShort) -> Int Source #sizes :: (CShort, CShort) -> [Int] Source #safeElem :: (CShort, CShort) -> CShort -> CShort Source #ordBounds :: (CShort, CShort) -> (CShort, CShort) Source #isEmpty :: (CShort, CShort) -> Bool Source #inBounds :: (CShort, CShort) -> CShort -> InBounds Source #isOverflow :: (CShort, CShort) -> CShort -> Bool Source #isUnderflow :: (CShort, CShort) -> CShort -> Bool Source #inRange :: (CShort, CShort) -> CShort -> Bool Source #prev :: (CShort, CShort) -> CShort -> CShort Source #next :: (CShort, CShort) -> CShort -> CShort Source #offset :: (CShort, CShort) -> CShort -> Int Source #index :: (CShort, CShort) -> Int -> CShort Source #range :: (CShort, CShort) -> [CShort] Source #subshape :: (Sub CShort j, Index (CShort :|: j)) => (CShort, CShort) -> (CShort :|: j) -> (j, j) Source #slice :: (Sub CShort j, ij ~ (CShort :|: j), Index j) => (CShort, CShort) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CUShort, CUShort) -> Int Source #sizes :: (CUShort, CUShort) -> [Int] Source #safeElem :: (CUShort, CUShort) -> CUShort -> CUShort Source #ordBounds :: (CUShort, CUShort) -> (CUShort, CUShort) Source #isEmpty :: (CUShort, CUShort) -> Bool Source #inBounds :: (CUShort, CUShort) -> CUShort -> InBounds Source #isOverflow :: (CUShort, CUShort) -> CUShort -> Bool Source #isUnderflow :: (CUShort, CUShort) -> CUShort -> Bool Source #inRange :: (CUShort, CUShort) -> CUShort -> Bool Source #prev :: (CUShort, CUShort) -> CUShort -> CUShort Source #next :: (CUShort, CUShort) -> CUShort -> CUShort Source #offset :: (CUShort, CUShort) -> CUShort -> Int Source #index :: (CUShort, CUShort) -> Int -> CUShort Source #range :: (CUShort, CUShort) -> [CUShort] Source #subshape :: (Sub CUShort j, Index (CUShort :|: j)) => (CUShort, CUShort) -> (CUShort :|: j) -> (j, j) Source #slice :: (Sub CUShort j, ij ~ (CUShort :|: j), Index j) => (CUShort, CUShort) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CInt, CInt) -> Int Source #sizes :: (CInt, CInt) -> [Int] Source #safeElem :: (CInt, CInt) -> CInt -> CInt Source #ordBounds :: (CInt, CInt) -> (CInt, CInt) Source #defaultBounds :: Int -> (CInt, CInt) Source #isEmpty :: (CInt, CInt) -> Bool Source #inBounds :: (CInt, CInt) -> CInt -> InBounds Source #isOverflow :: (CInt, CInt) -> CInt -> Bool Source #isUnderflow :: (CInt, CInt) -> CInt -> Bool Source #inRange :: (CInt, CInt) -> CInt -> Bool Source #prev :: (CInt, CInt) -> CInt -> CInt Source #next :: (CInt, CInt) -> CInt -> CInt Source #offset :: (CInt, CInt) -> CInt -> Int Source #index :: (CInt, CInt) -> Int -> CInt Source #range :: (CInt, CInt) -> [CInt] Source #subshape :: (Sub CInt j, Index (CInt :|: j)) => (CInt, CInt) -> (CInt :|: j) -> (j, j) Source #slice :: (Sub CInt j, ij ~ (CInt :|: j), Index j) => (CInt, CInt) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CUInt, CUInt) -> Int Source #sizes :: (CUInt, CUInt) -> [Int] Source #safeElem :: (CUInt, CUInt) -> CUInt -> CUInt Source #ordBounds :: (CUInt, CUInt) -> (CUInt, CUInt) Source #isEmpty :: (CUInt, CUInt) -> Bool Source #inBounds :: (CUInt, CUInt) -> CUInt -> InBounds Source #isOverflow :: (CUInt, CUInt) -> CUInt -> Bool Source #isUnderflow :: (CUInt, CUInt) -> CUInt -> Bool Source #inRange :: (CUInt, CUInt) -> CUInt -> Bool Source #prev :: (CUInt, CUInt) -> CUInt -> CUInt Source #next :: (CUInt, CUInt) -> CUInt -> CUInt Source #offset :: (CUInt, CUInt) -> CUInt -> Int Source #index :: (CUInt, CUInt) -> Int -> CUInt Source #range :: (CUInt, CUInt) -> [CUInt] Source #subshape :: (Sub CUInt j, Index (CUInt :|: j)) => (CUInt, CUInt) -> (CUInt :|: j) -> (j, j) Source #slice :: (Sub CUInt j, ij ~ (CUInt :|: j), Index j) => (CUInt, CUInt) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CLong, CLong) -> Int Source #sizes :: (CLong, CLong) -> [Int] Source #safeElem :: (CLong, CLong) -> CLong -> CLong Source #ordBounds :: (CLong, CLong) -> (CLong, CLong) Source #isEmpty :: (CLong, CLong) -> Bool Source #inBounds :: (CLong, CLong) -> CLong -> InBounds Source #isOverflow :: (CLong, CLong) -> CLong -> Bool Source #isUnderflow :: (CLong, CLong) -> CLong -> Bool Source #inRange :: (CLong, CLong) -> CLong -> Bool Source #prev :: (CLong, CLong) -> CLong -> CLong Source #next :: (CLong, CLong) -> CLong -> CLong Source #offset :: (CLong, CLong) -> CLong -> Int Source #index :: (CLong, CLong) -> Int -> CLong Source #range :: (CLong, CLong) -> [CLong] Source #subshape :: (Sub CLong j, Index (CLong :|: j)) => (CLong, CLong) -> (CLong :|: j) -> (j, j) Source #slice :: (Sub CLong j, ij ~ (CLong :|: j), Index j) => (CLong, CLong) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CULong, CULong) -> Int Source #sizes :: (CULong, CULong) -> [Int] Source #safeElem :: (CULong, CULong) -> CULong -> CULong Source #ordBounds :: (CULong, CULong) -> (CULong, CULong) Source #isEmpty :: (CULong, CULong) -> Bool Source #inBounds :: (CULong, CULong) -> CULong -> InBounds Source #isOverflow :: (CULong, CULong) -> CULong -> Bool Source #isUnderflow :: (CULong, CULong) -> CULong -> Bool Source #inRange :: (CULong, CULong) -> CULong -> Bool Source #prev :: (CULong, CULong) -> CULong -> CULong Source #next :: (CULong, CULong) -> CULong -> CULong Source #offset :: (CULong, CULong) -> CULong -> Int Source #index :: (CULong, CULong) -> Int -> CULong Source #range :: (CULong, CULong) -> [CULong] Source #subshape :: (Sub CULong j, Index (CULong :|: j)) => (CULong, CULong) -> (CULong :|: j) -> (j, j) Source #slice :: (Sub CULong j, ij ~ (CULong :|: j), Index j) => (CULong, CULong) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CLLong, CLLong) -> Int Source #sizes :: (CLLong, CLLong) -> [Int] Source #safeElem :: (CLLong, CLLong) -> CLLong -> CLLong Source #ordBounds :: (CLLong, CLLong) -> (CLLong, CLLong) Source #isEmpty :: (CLLong, CLLong) -> Bool Source #inBounds :: (CLLong, CLLong) -> CLLong -> InBounds Source #isOverflow :: (CLLong, CLLong) -> CLLong -> Bool Source #isUnderflow :: (CLLong, CLLong) -> CLLong -> Bool Source #inRange :: (CLLong, CLLong) -> CLLong -> Bool Source #prev :: (CLLong, CLLong) -> CLLong -> CLLong Source #next :: (CLLong, CLLong) -> CLLong -> CLLong Source #offset :: (CLLong, CLLong) -> CLLong -> Int Source #index :: (CLLong, CLLong) -> Int -> CLLong Source #range :: (CLLong, CLLong) -> [CLLong] Source #subshape :: (Sub CLLong j, Index (CLLong :|: j)) => (CLLong, CLLong) -> (CLLong :|: j) -> (j, j) Source #slice :: (Sub CLLong j, ij ~ (CLLong :|: j), Index j) => (CLLong, CLLong) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CULLong, CULLong) -> Int Source #sizes :: (CULLong, CULLong) -> [Int] Source #safeElem :: (CULLong, CULLong) -> CULLong -> CULLong Source #ordBounds :: (CULLong, CULLong) -> (CULLong, CULLong) Source #isEmpty :: (CULLong, CULLong) -> Bool Source #inBounds :: (CULLong, CULLong) -> CULLong -> InBounds Source #isOverflow :: (CULLong, CULLong) -> CULLong -> Bool Source #isUnderflow :: (CULLong, CULLong) -> CULLong -> Bool Source #inRange :: (CULLong, CULLong) -> CULLong -> Bool Source #prev :: (CULLong, CULLong) -> CULLong -> CULLong Source #next :: (CULLong, CULLong) -> CULLong -> CULLong Source #offset :: (CULLong, CULLong) -> CULLong -> Int Source #index :: (CULLong, CULLong) -> Int -> CULLong Source #range :: (CULLong, CULLong) -> [CULLong] Source #subshape :: (Sub CULLong j, Index (CULLong :|: j)) => (CULLong, CULLong) -> (CULLong :|: j) -> (j, j) Source #slice :: (Sub CULLong j, ij ~ (CULLong :|: j), Index j) => (CULLong, CULLong) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CBool, CBool) -> Int Source #sizes :: (CBool, CBool) -> [Int] Source #safeElem :: (CBool, CBool) -> CBool -> CBool Source #ordBounds :: (CBool, CBool) -> (CBool, CBool) Source #isEmpty :: (CBool, CBool) -> Bool Source #inBounds :: (CBool, CBool) -> CBool -> InBounds Source #isOverflow :: (CBool, CBool) -> CBool -> Bool Source #isUnderflow :: (CBool, CBool) -> CBool -> Bool Source #inRange :: (CBool, CBool) -> CBool -> Bool Source #prev :: (CBool, CBool) -> CBool -> CBool Source #next :: (CBool, CBool) -> CBool -> CBool Source #offset :: (CBool, CBool) -> CBool -> Int Source #index :: (CBool, CBool) -> Int -> CBool Source #range :: (CBool, CBool) -> [CBool] Source #subshape :: (Sub CBool j, Index (CBool :|: j)) => (CBool, CBool) -> (CBool :|: j) -> (j, j) Source #slice :: (Sub CBool j, ij ~ (CBool :|: j), Index j) => (CBool, CBool) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CPtrdiff, CPtrdiff) -> Int Source #sizes :: (CPtrdiff, CPtrdiff) -> [Int] Source #ordBounds :: (CPtrdiff, CPtrdiff) -> (CPtrdiff, CPtrdiff) Source #isEmpty :: (CPtrdiff, CPtrdiff) -> Bool Source #inRange :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Bool Source #prev :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> CPtrdiff Source #next :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> CPtrdiff Source #offset :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Int Source #index :: (CPtrdiff, CPtrdiff) -> Int -> CPtrdiff Source #range :: (CPtrdiff, CPtrdiff) -> [CPtrdiff] Source #subshape :: (Sub CPtrdiff j, Index (CPtrdiff :|: j)) => (CPtrdiff, CPtrdiff) -> (CPtrdiff :|: j) -> (j, j) Source #slice :: (Sub CPtrdiff j, ij ~ (CPtrdiff :|: j), Index j) => (CPtrdiff, CPtrdiff) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CSize, CSize) -> Int Source #sizes :: (CSize, CSize) -> [Int] Source #safeElem :: (CSize, CSize) -> CSize -> CSize Source #ordBounds :: (CSize, CSize) -> (CSize, CSize) Source #isEmpty :: (CSize, CSize) -> Bool Source #inBounds :: (CSize, CSize) -> CSize -> InBounds Source #isOverflow :: (CSize, CSize) -> CSize -> Bool Source #isUnderflow :: (CSize, CSize) -> CSize -> Bool Source #inRange :: (CSize, CSize) -> CSize -> Bool Source #prev :: (CSize, CSize) -> CSize -> CSize Source #next :: (CSize, CSize) -> CSize -> CSize Source #offset :: (CSize, CSize) -> CSize -> Int Source #index :: (CSize, CSize) -> Int -> CSize Source #range :: (CSize, CSize) -> [CSize] Source #subshape :: (Sub CSize j, Index (CSize :|: j)) => (CSize, CSize) -> (CSize :|: j) -> (j, j) Source #slice :: (Sub CSize j, ij ~ (CSize :|: j), Index j) => (CSize, CSize) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CWchar, CWchar) -> Int Source #sizes :: (CWchar, CWchar) -> [Int] Source #safeElem :: (CWchar, CWchar) -> CWchar -> CWchar Source #ordBounds :: (CWchar, CWchar) -> (CWchar, CWchar) Source #isEmpty :: (CWchar, CWchar) -> Bool Source #inBounds :: (CWchar, CWchar) -> CWchar -> InBounds Source #isOverflow :: (CWchar, CWchar) -> CWchar -> Bool Source #isUnderflow :: (CWchar, CWchar) -> CWchar -> Bool Source #inRange :: (CWchar, CWchar) -> CWchar -> Bool Source #prev :: (CWchar, CWchar) -> CWchar -> CWchar Source #next :: (CWchar, CWchar) -> CWchar -> CWchar Source #offset :: (CWchar, CWchar) -> CWchar -> Int Source #index :: (CWchar, CWchar) -> Int -> CWchar Source #range :: (CWchar, CWchar) -> [CWchar] Source #subshape :: (Sub CWchar j, Index (CWchar :|: j)) => (CWchar, CWchar) -> (CWchar :|: j) -> (j, j) Source #slice :: (Sub CWchar j, ij ~ (CWchar :|: j), Index j) => (CWchar, CWchar) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CSigAtomic, CSigAtomic) -> Int Source #sizes :: (CSigAtomic, CSigAtomic) -> [Int] Source #range :: (CSigAtomic, CSigAtomic) -> [CSigAtomic] Source #subshape :: (Sub CSigAtomic j, Index (CSigAtomic :|: j)) => (CSigAtomic, CSigAtomic) -> (CSigAtomic :|: j) -> (j, j) Source #slice :: (Sub CSigAtomic j, ij ~ (CSigAtomic :|: j), Index j) => (CSigAtomic, CSigAtomic) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CIntPtr, CIntPtr) -> Int Source #sizes :: (CIntPtr, CIntPtr) -> [Int] Source #safeElem :: (CIntPtr, CIntPtr) -> CIntPtr -> CIntPtr Source #ordBounds :: (CIntPtr, CIntPtr) -> (CIntPtr, CIntPtr) Source #isEmpty :: (CIntPtr, CIntPtr) -> Bool Source #inBounds :: (CIntPtr, CIntPtr) -> CIntPtr -> InBounds Source #isOverflow :: (CIntPtr, CIntPtr) -> CIntPtr -> Bool Source #isUnderflow :: (CIntPtr, CIntPtr) -> CIntPtr -> Bool Source #inRange :: (CIntPtr, CIntPtr) -> CIntPtr -> Bool Source #prev :: (CIntPtr, CIntPtr) -> CIntPtr -> CIntPtr Source #next :: (CIntPtr, CIntPtr) -> CIntPtr -> CIntPtr Source #offset :: (CIntPtr, CIntPtr) -> CIntPtr -> Int Source #index :: (CIntPtr, CIntPtr) -> Int -> CIntPtr Source #range :: (CIntPtr, CIntPtr) -> [CIntPtr] Source #subshape :: (Sub CIntPtr j, Index (CIntPtr :|: j)) => (CIntPtr, CIntPtr) -> (CIntPtr :|: j) -> (j, j) Source #slice :: (Sub CIntPtr j, ij ~ (CIntPtr :|: j), Index j) => (CIntPtr, CIntPtr) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CUIntPtr, CUIntPtr) -> Int Source #sizes :: (CUIntPtr, CUIntPtr) -> [Int] Source #ordBounds :: (CUIntPtr, CUIntPtr) -> (CUIntPtr, CUIntPtr) Source #isEmpty :: (CUIntPtr, CUIntPtr) -> Bool Source #inRange :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Bool Source #prev :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> CUIntPtr Source #next :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> CUIntPtr Source #offset :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int Source #index :: (CUIntPtr, CUIntPtr) -> Int -> CUIntPtr Source #range :: (CUIntPtr, CUIntPtr) -> [CUIntPtr] Source #subshape :: (Sub CUIntPtr j, Index (CUIntPtr :|: j)) => (CUIntPtr, CUIntPtr) -> (CUIntPtr :|: j) -> (j, j) Source #slice :: (Sub CUIntPtr j, ij ~ (CUIntPtr :|: j), Index j) => (CUIntPtr, CUIntPtr) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CIntMax, CIntMax) -> Int Source #sizes :: (CIntMax, CIntMax) -> [Int] Source #safeElem :: (CIntMax, CIntMax) -> CIntMax -> CIntMax Source #ordBounds :: (CIntMax, CIntMax) -> (CIntMax, CIntMax) Source #isEmpty :: (CIntMax, CIntMax) -> Bool Source #inBounds :: (CIntMax, CIntMax) -> CIntMax -> InBounds Source #isOverflow :: (CIntMax, CIntMax) -> CIntMax -> Bool Source #isUnderflow :: (CIntMax, CIntMax) -> CIntMax -> Bool Source #inRange :: (CIntMax, CIntMax) -> CIntMax -> Bool Source #prev :: (CIntMax, CIntMax) -> CIntMax -> CIntMax Source #next :: (CIntMax, CIntMax) -> CIntMax -> CIntMax Source #offset :: (CIntMax, CIntMax) -> CIntMax -> Int Source #index :: (CIntMax, CIntMax) -> Int -> CIntMax Source #range :: (CIntMax, CIntMax) -> [CIntMax] Source #subshape :: (Sub CIntMax j, Index (CIntMax :|: j)) => (CIntMax, CIntMax) -> (CIntMax :|: j) -> (j, j) Source #slice :: (Sub CIntMax j, ij ~ (CIntMax :|: j), Index j) => (CIntMax, CIntMax) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (CUIntMax, CUIntMax) -> Int Source #sizes :: (CUIntMax, CUIntMax) -> [Int] Source #ordBounds :: (CUIntMax, CUIntMax) -> (CUIntMax, CUIntMax) Source #isEmpty :: (CUIntMax, CUIntMax) -> Bool Source #inRange :: (CUIntMax, CUIntMax) -> CUIntMax -> Bool Source #prev :: (CUIntMax, CUIntMax) -> CUIntMax -> CUIntMax Source #next :: (CUIntMax, CUIntMax) -> CUIntMax -> CUIntMax Source #offset :: (CUIntMax, CUIntMax) -> CUIntMax -> Int Source #index :: (CUIntMax, CUIntMax) -> Int -> CUIntMax Source #range :: (CUIntMax, CUIntMax) -> [CUIntMax] Source #subshape :: (Sub CUIntMax j, Index (CUIntMax :|: j)) => (CUIntMax, CUIntMax) -> (CUIntMax :|: j) -> (j, j) Source #slice :: (Sub CUIntMax j, ij ~ (CUIntMax :|: j), Index j) => (CUIntMax, CUIntMax) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Index Methodssize :: (E, E) -> Int Source #sizes :: (E, E) -> [Int] Source #safeElem :: (E, E) -> E -> E Source #ordBounds :: (E, E) -> (E, E) Source #defaultBounds :: Int -> (E, E) Source #isEmpty :: (E, E) -> Bool Source #inBounds :: (E, E) -> E -> InBounds Source #isOverflow :: (E, E) -> E -> Bool Source #isUnderflow :: (E, E) -> E -> Bool Source #inRange :: (E, E) -> E -> Bool Source #prev :: (E, E) -> E -> E Source #next :: (E, E) -> E -> E Source #offset :: (E, E) -> E -> Int Source #index :: (E, E) -> Int -> E Source #range :: (E, E) -> [E] Source #subshape :: (Sub E j, Index (E :|: j)) => (E, E) -> (E :|: j) -> (j, j) Source #slice :: (Sub E j, ij ~ (E :|: j), Index j) => (E, E) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Unboxed.IntAs Methodssize :: (IntAs64, IntAs64) -> Int Source #sizes :: (IntAs64, IntAs64) -> [Int] Source #safeElem :: (IntAs64, IntAs64) -> IntAs64 -> IntAs64 Source #ordBounds :: (IntAs64, IntAs64) -> (IntAs64, IntAs64) Source #isEmpty :: (IntAs64, IntAs64) -> Bool Source #inBounds :: (IntAs64, IntAs64) -> IntAs64 -> InBounds Source #isOverflow :: (IntAs64, IntAs64) -> IntAs64 -> Bool Source #isUnderflow :: (IntAs64, IntAs64) -> IntAs64 -> Bool Source #inRange :: (IntAs64, IntAs64) -> IntAs64 -> Bool Source #prev :: (IntAs64, IntAs64) -> IntAs64 -> IntAs64 Source #next :: (IntAs64, IntAs64) -> IntAs64 -> IntAs64 Source #offset :: (IntAs64, IntAs64) -> IntAs64 -> Int Source #index :: (IntAs64, IntAs64) -> Int -> IntAs64 Source #range :: (IntAs64, IntAs64) -> [IntAs64] Source #subshape :: (Sub IntAs64 j, Index (IntAs64 :|: j)) => (IntAs64, IntAs64) -> (IntAs64 :|: j) -> (j, j) Source #slice :: (Sub IntAs64 j, ij ~ (IntAs64 :|: j), Index j) => (IntAs64, IntAs64) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Unboxed.IntAs Methodssize :: (IntAs32, IntAs32) -> Int Source #sizes :: (IntAs32, IntAs32) -> [Int] Source #safeElem :: (IntAs32, IntAs32) -> IntAs32 -> IntAs32 Source #ordBounds :: (IntAs32, IntAs32) -> (IntAs32, IntAs32) Source #isEmpty :: (IntAs32, IntAs32) -> Bool Source #inBounds :: (IntAs32, IntAs32) -> IntAs32 -> InBounds Source #isOverflow :: (IntAs32, IntAs32) -> IntAs32 -> Bool Source #isUnderflow :: (IntAs32, IntAs32) -> IntAs32 -> Bool Source #inRange :: (IntAs32, IntAs32) -> IntAs32 -> Bool Source #prev :: (IntAs32, IntAs32) -> IntAs32 -> IntAs32 Source #next :: (IntAs32, IntAs32) -> IntAs32 -> IntAs32 Source #offset :: (IntAs32, IntAs32) -> IntAs32 -> Int Source #index :: (IntAs32, IntAs32) -> Int -> IntAs32 Source #range :: (IntAs32, IntAs32) -> [IntAs32] Source #subshape :: (Sub IntAs32 j, Index (IntAs32 :|: j)) => (IntAs32, IntAs32) -> (IntAs32 :|: j) -> (j, j) Source #slice :: (Sub IntAs32 j, ij ~ (IntAs32 :|: j), Index j) => (IntAs32, IntAs32) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Unboxed.IntAs Methodssize :: (IntAs16, IntAs16) -> Int Source #sizes :: (IntAs16, IntAs16) -> [Int] Source #safeElem :: (IntAs16, IntAs16) -> IntAs16 -> IntAs16 Source #ordBounds :: (IntAs16, IntAs16) -> (IntAs16, IntAs16) Source #isEmpty :: (IntAs16, IntAs16) -> Bool Source #inBounds :: (IntAs16, IntAs16) -> IntAs16 -> InBounds Source #isOverflow :: (IntAs16, IntAs16) -> IntAs16 -> Bool Source #isUnderflow :: (IntAs16, IntAs16) -> IntAs16 -> Bool Source #inRange :: (IntAs16, IntAs16) -> IntAs16 -> Bool Source #prev :: (IntAs16, IntAs16) -> IntAs16 -> IntAs16 Source #next :: (IntAs16, IntAs16) -> IntAs16 -> IntAs16 Source #offset :: (IntAs16, IntAs16) -> IntAs16 -> Int Source #index :: (IntAs16, IntAs16) -> Int -> IntAs16 Source #range :: (IntAs16, IntAs16) -> [IntAs16] Source #subshape :: (Sub IntAs16 j, Index (IntAs16 :|: j)) => (IntAs16, IntAs16) -> (IntAs16 :|: j) -> (j, j) Source #slice :: (Sub IntAs16 j, ij ~ (IntAs16 :|: j), Index j) => (IntAs16, IntAs16) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Unboxed.IntAs Methodssize :: (IntAs8, IntAs8) -> Int Source #sizes :: (IntAs8, IntAs8) -> [Int] Source #safeElem :: (IntAs8, IntAs8) -> IntAs8 -> IntAs8 Source #ordBounds :: (IntAs8, IntAs8) -> (IntAs8, IntAs8) Source #isEmpty :: (IntAs8, IntAs8) -> Bool Source #inBounds :: (IntAs8, IntAs8) -> IntAs8 -> InBounds Source #isOverflow :: (IntAs8, IntAs8) -> IntAs8 -> Bool Source #isUnderflow :: (IntAs8, IntAs8) -> IntAs8 -> Bool Source #inRange :: (IntAs8, IntAs8) -> IntAs8 -> Bool Source #prev :: (IntAs8, IntAs8) -> IntAs8 -> IntAs8 Source #next :: (IntAs8, IntAs8) -> IntAs8 -> IntAs8 Source #offset :: (IntAs8, IntAs8) -> IntAs8 -> Int Source #index :: (IntAs8, IntAs8) -> Int -> IntAs8 Source #range :: (IntAs8, IntAs8) -> [IntAs8] Source #subshape :: (Sub IntAs8 j, Index (IntAs8 :|: j)) => (IntAs8, IntAs8) -> (IntAs8 :|: j) -> (j, j) Source #slice :: (Sub IntAs8 j, ij ~ (IntAs8 :|: j), Index j) => (IntAs8, IntAs8) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Unboxed.WordAs Methodssize :: (WordAs64, WordAs64) -> Int Source #sizes :: (WordAs64, WordAs64) -> [Int] Source #ordBounds :: (WordAs64, WordAs64) -> (WordAs64, WordAs64) Source #isEmpty :: (WordAs64, WordAs64) -> Bool Source #inRange :: (WordAs64, WordAs64) -> WordAs64 -> Bool Source #prev :: (WordAs64, WordAs64) -> WordAs64 -> WordAs64 Source #next :: (WordAs64, WordAs64) -> WordAs64 -> WordAs64 Source #offset :: (WordAs64, WordAs64) -> WordAs64 -> Int Source #index :: (WordAs64, WordAs64) -> Int -> WordAs64 Source #range :: (WordAs64, WordAs64) -> [WordAs64] Source #subshape :: (Sub WordAs64 j, Index (WordAs64 :|: j)) => (WordAs64, WordAs64) -> (WordAs64 :|: j) -> (j, j) Source #slice :: (Sub WordAs64 j, ij ~ (WordAs64 :|: j), Index j) => (WordAs64, WordAs64) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Unboxed.WordAs Methodssize :: (WordAs32, WordAs32) -> Int Source #sizes :: (WordAs32, WordAs32) -> [Int] Source #ordBounds :: (WordAs32, WordAs32) -> (WordAs32, WordAs32) Source #isEmpty :: (WordAs32, WordAs32) -> Bool Source #inRange :: (WordAs32, WordAs32) -> WordAs32 -> Bool Source #prev :: (WordAs32, WordAs32) -> WordAs32 -> WordAs32 Source #next :: (WordAs32, WordAs32) -> WordAs32 -> WordAs32 Source #offset :: (WordAs32, WordAs32) -> WordAs32 -> Int Source #index :: (WordAs32, WordAs32) -> Int -> WordAs32 Source #range :: (WordAs32, WordAs32) -> [WordAs32] Source #subshape :: (Sub WordAs32 j, Index (WordAs32 :|: j)) => (WordAs32, WordAs32) -> (WordAs32 :|: j) -> (j, j) Source #slice :: (Sub WordAs32 j, ij ~ (WordAs32 :|: j), Index j) => (WordAs32, WordAs32) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Unboxed.WordAs Methodssize :: (WordAs16, WordAs16) -> Int Source #sizes :: (WordAs16, WordAs16) -> [Int] Source #ordBounds :: (WordAs16, WordAs16) -> (WordAs16, WordAs16) Source #isEmpty :: (WordAs16, WordAs16) -> Bool Source #inRange :: (WordAs16, WordAs16) -> WordAs16 -> Bool Source #prev :: (WordAs16, WordAs16) -> WordAs16 -> WordAs16 Source #next :: (WordAs16, WordAs16) -> WordAs16 -> WordAs16 Source #offset :: (WordAs16, WordAs16) -> WordAs16 -> Int Source #index :: (WordAs16, WordAs16) -> Int -> WordAs16 Source #range :: (WordAs16, WordAs16) -> [WordAs16] Source #subshape :: (Sub WordAs16 j, Index (WordAs16 :|: j)) => (WordAs16, WordAs16) -> (WordAs16 :|: j) -> (j, j) Source #slice :: (Sub WordAs16 j, ij ~ (WordAs16 :|: j), Index j) => (WordAs16, WordAs16) -> ij -> ((ij, ij), (j, j)) Source # Source # Instance detailsDefined in SDP.Unboxed.WordAs Methodssize :: (WordAs8, WordAs8) -> Int Source #sizes :: (WordAs8, WordAs8) -> [Int] Source #safeElem :: (WordAs8, WordAs8) -> WordAs8 -> WordAs8 Source #ordBounds :: (WordAs8, WordAs8) -> (WordAs8, WordAs8) Source #isEmpty :: (WordAs8, WordAs8) -> Bool Source #inBounds :: (WordAs8, WordAs8) -> WordAs8 -> InBounds Source #isOverflow :: (WordAs8, WordAs8) -> WordAs8 -> Bool Source #isUnderflow :: (WordAs8, WordAs8) -> WordAs8 -> Bool Source #inRange :: (WordAs8, WordAs8) -> WordAs8 -> Bool Source #prev :: (WordAs8, WordAs8) -> WordAs8 -> WordAs8 Source #next :: (WordAs8, WordAs8) -> WordAs8 -> WordAs8 Source #offset :: (WordAs8, WordAs8) -> WordAs8 -> Int Source #index :: (WordAs8, WordAs8) -> Int -> WordAs8 Source #range :: (WordAs8, WordAs8) -> [WordAs8] Source #subshape :: (Sub WordAs8 j, Index (WordAs8 :|: j)) => (WordAs8, WordAs8) -> (WordAs8 :|: j) -> (j, j) Source #slice :: (Sub WordAs8 j, ij ~ (WordAs8 :|: j), Index j) => (WordAs8, WordAs8) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T15 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T15 i, T15 i) -> Int Source #sizes :: (T15 i, T15 i) -> [Int] Source #safeElem :: (T15 i, T15 i) -> T15 i -> T15 i Source #ordBounds :: (T15 i, T15 i) -> (T15 i, T15 i) Source #defaultBounds :: Int -> (T15 i, T15 i) Source #isEmpty :: (T15 i, T15 i) -> Bool Source #inBounds :: (T15 i, T15 i) -> T15 i -> InBounds Source #isOverflow :: (T15 i, T15 i) -> T15 i -> Bool Source #isUnderflow :: (T15 i, T15 i) -> T15 i -> Bool Source #inRange :: (T15 i, T15 i) -> T15 i -> Bool Source #prev :: (T15 i, T15 i) -> T15 i -> T15 i Source #next :: (T15 i, T15 i) -> T15 i -> T15 i Source #offset :: (T15 i, T15 i) -> T15 i -> Int Source #index :: (T15 i, T15 i) -> Int -> T15 i Source #range :: (T15 i, T15 i) -> [T15 i] Source #subshape :: (Sub (T15 i) j, Index (T15 i :|: j)) => (T15 i, T15 i) -> (T15 i :|: j) -> (j, j) Source #slice :: (Sub (T15 i) j, ij ~ (T15 i :|: j), Index j) => (T15 i, T15 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T14 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T14 i, T14 i) -> Int Source #sizes :: (T14 i, T14 i) -> [Int] Source #safeElem :: (T14 i, T14 i) -> T14 i -> T14 i Source #ordBounds :: (T14 i, T14 i) -> (T14 i, T14 i) Source #defaultBounds :: Int -> (T14 i, T14 i) Source #isEmpty :: (T14 i, T14 i) -> Bool Source #inBounds :: (T14 i, T14 i) -> T14 i -> InBounds Source #isOverflow :: (T14 i, T14 i) -> T14 i -> Bool Source #isUnderflow :: (T14 i, T14 i) -> T14 i -> Bool Source #inRange :: (T14 i, T14 i) -> T14 i -> Bool Source #prev :: (T14 i, T14 i) -> T14 i -> T14 i Source #next :: (T14 i, T14 i) -> T14 i -> T14 i Source #offset :: (T14 i, T14 i) -> T14 i -> Int Source #index :: (T14 i, T14 i) -> Int -> T14 i Source #range :: (T14 i, T14 i) -> [T14 i] Source #subshape :: (Sub (T14 i) j, Index (T14 i :|: j)) => (T14 i, T14 i) -> (T14 i :|: j) -> (j, j) Source #slice :: (Sub (T14 i) j, ij ~ (T14 i :|: j), Index j) => (T14 i, T14 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T13 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T13 i, T13 i) -> Int Source #sizes :: (T13 i, T13 i) -> [Int] Source #safeElem :: (T13 i, T13 i) -> T13 i -> T13 i Source #ordBounds :: (T13 i, T13 i) -> (T13 i, T13 i) Source #defaultBounds :: Int -> (T13 i, T13 i) Source #isEmpty :: (T13 i, T13 i) -> Bool Source #inBounds :: (T13 i, T13 i) -> T13 i -> InBounds Source #isOverflow :: (T13 i, T13 i) -> T13 i -> Bool Source #isUnderflow :: (T13 i, T13 i) -> T13 i -> Bool Source #inRange :: (T13 i, T13 i) -> T13 i -> Bool Source #prev :: (T13 i, T13 i) -> T13 i -> T13 i Source #next :: (T13 i, T13 i) -> T13 i -> T13 i Source #offset :: (T13 i, T13 i) -> T13 i -> Int Source #index :: (T13 i, T13 i) -> Int -> T13 i Source #range :: (T13 i, T13 i) -> [T13 i] Source #subshape :: (Sub (T13 i) j, Index (T13 i :|: j)) => (T13 i, T13 i) -> (T13 i :|: j) -> (j, j) Source #slice :: (Sub (T13 i) j, ij ~ (T13 i :|: j), Index j) => (T13 i, T13 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T12 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T12 i, T12 i) -> Int Source #sizes :: (T12 i, T12 i) -> [Int] Source #safeElem :: (T12 i, T12 i) -> T12 i -> T12 i Source #ordBounds :: (T12 i, T12 i) -> (T12 i, T12 i) Source #defaultBounds :: Int -> (T12 i, T12 i) Source #isEmpty :: (T12 i, T12 i) -> Bool Source #inBounds :: (T12 i, T12 i) -> T12 i -> InBounds Source #isOverflow :: (T12 i, T12 i) -> T12 i -> Bool Source #isUnderflow :: (T12 i, T12 i) -> T12 i -> Bool Source #inRange :: (T12 i, T12 i) -> T12 i -> Bool Source #prev :: (T12 i, T12 i) -> T12 i -> T12 i Source #next :: (T12 i, T12 i) -> T12 i -> T12 i Source #offset :: (T12 i, T12 i) -> T12 i -> Int Source #index :: (T12 i, T12 i) -> Int -> T12 i Source #range :: (T12 i, T12 i) -> [T12 i] Source #subshape :: (Sub (T12 i) j, Index (T12 i :|: j)) => (T12 i, T12 i) -> (T12 i :|: j) -> (j, j) Source #slice :: (Sub (T12 i) j, ij ~ (T12 i :|: j), Index j) => (T12 i, T12 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T11 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T11 i, T11 i) -> Int Source #sizes :: (T11 i, T11 i) -> [Int] Source #safeElem :: (T11 i, T11 i) -> T11 i -> T11 i Source #ordBounds :: (T11 i, T11 i) -> (T11 i, T11 i) Source #defaultBounds :: Int -> (T11 i, T11 i) Source #isEmpty :: (T11 i, T11 i) -> Bool Source #inBounds :: (T11 i, T11 i) -> T11 i -> InBounds Source #isOverflow :: (T11 i, T11 i) -> T11 i -> Bool Source #isUnderflow :: (T11 i, T11 i) -> T11 i -> Bool Source #inRange :: (T11 i, T11 i) -> T11 i -> Bool Source #prev :: (T11 i, T11 i) -> T11 i -> T11 i Source #next :: (T11 i, T11 i) -> T11 i -> T11 i Source #offset :: (T11 i, T11 i) -> T11 i -> Int Source #index :: (T11 i, T11 i) -> Int -> T11 i Source #range :: (T11 i, T11 i) -> [T11 i] Source #subshape :: (Sub (T11 i) j, Index (T11 i :|: j)) => (T11 i, T11 i) -> (T11 i :|: j) -> (j, j) Source #slice :: (Sub (T11 i) j, ij ~ (T11 i :|: j), Index j) => (T11 i, T11 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T10 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T10 i, T10 i) -> Int Source #sizes :: (T10 i, T10 i) -> [Int] Source #safeElem :: (T10 i, T10 i) -> T10 i -> T10 i Source #ordBounds :: (T10 i, T10 i) -> (T10 i, T10 i) Source #defaultBounds :: Int -> (T10 i, T10 i) Source #isEmpty :: (T10 i, T10 i) -> Bool Source #inBounds :: (T10 i, T10 i) -> T10 i -> InBounds Source #isOverflow :: (T10 i, T10 i) -> T10 i -> Bool Source #isUnderflow :: (T10 i, T10 i) -> T10 i -> Bool Source #inRange :: (T10 i, T10 i) -> T10 i -> Bool Source #prev :: (T10 i, T10 i) -> T10 i -> T10 i Source #next :: (T10 i, T10 i) -> T10 i -> T10 i Source #offset :: (T10 i, T10 i) -> T10 i -> Int Source #index :: (T10 i, T10 i) -> Int -> T10 i Source #range :: (T10 i, T10 i) -> [T10 i] Source #subshape :: (Sub (T10 i) j, Index (T10 i :|: j)) => (T10 i, T10 i) -> (T10 i :|: j) -> (j, j) Source #slice :: (Sub (T10 i) j, ij ~ (T10 i :|: j), Index j) => (T10 i, T10 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T9 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T9 i, T9 i) -> Int Source #sizes :: (T9 i, T9 i) -> [Int] Source #safeElem :: (T9 i, T9 i) -> T9 i -> T9 i Source #ordBounds :: (T9 i, T9 i) -> (T9 i, T9 i) Source #defLimit :: T9 i -> Integer Source #defaultBounds :: Int -> (T9 i, T9 i) Source #isEmpty :: (T9 i, T9 i) -> Bool Source #inBounds :: (T9 i, T9 i) -> T9 i -> InBounds Source #isOverflow :: (T9 i, T9 i) -> T9 i -> Bool Source #isUnderflow :: (T9 i, T9 i) -> T9 i -> Bool Source #inRange :: (T9 i, T9 i) -> T9 i -> Bool Source #prev :: (T9 i, T9 i) -> T9 i -> T9 i Source #next :: (T9 i, T9 i) -> T9 i -> T9 i Source #offset :: (T9 i, T9 i) -> T9 i -> Int Source #index :: (T9 i, T9 i) -> Int -> T9 i Source #range :: (T9 i, T9 i) -> [T9 i] Source #subshape :: (Sub (T9 i) j, Index (T9 i :|: j)) => (T9 i, T9 i) -> (T9 i :|: j) -> (j, j) Source #slice :: (Sub (T9 i) j, ij ~ (T9 i :|: j), Index j) => (T9 i, T9 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T8 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T8 i, T8 i) -> Int Source #sizes :: (T8 i, T8 i) -> [Int] Source #safeElem :: (T8 i, T8 i) -> T8 i -> T8 i Source #ordBounds :: (T8 i, T8 i) -> (T8 i, T8 i) Source #defLimit :: T8 i -> Integer Source #defaultBounds :: Int -> (T8 i, T8 i) Source #isEmpty :: (T8 i, T8 i) -> Bool Source #inBounds :: (T8 i, T8 i) -> T8 i -> InBounds Source #isOverflow :: (T8 i, T8 i) -> T8 i -> Bool Source #isUnderflow :: (T8 i, T8 i) -> T8 i -> Bool Source #inRange :: (T8 i, T8 i) -> T8 i -> Bool Source #prev :: (T8 i, T8 i) -> T8 i -> T8 i Source #next :: (T8 i, T8 i) -> T8 i -> T8 i Source #offset :: (T8 i, T8 i) -> T8 i -> Int Source #index :: (T8 i, T8 i) -> Int -> T8 i Source #range :: (T8 i, T8 i) -> [T8 i] Source #subshape :: (Sub (T8 i) j, Index (T8 i :|: j)) => (T8 i, T8 i) -> (T8 i :|: j) -> (j, j) Source #slice :: (Sub (T8 i) j, ij ~ (T8 i :|: j), Index j) => (T8 i, T8 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T7 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T7 i, T7 i) -> Int Source #sizes :: (T7 i, T7 i) -> [Int] Source #safeElem :: (T7 i, T7 i) -> T7 i -> T7 i Source #ordBounds :: (T7 i, T7 i) -> (T7 i, T7 i) Source #defLimit :: T7 i -> Integer Source #defaultBounds :: Int -> (T7 i, T7 i) Source #isEmpty :: (T7 i, T7 i) -> Bool Source #inBounds :: (T7 i, T7 i) -> T7 i -> InBounds Source #isOverflow :: (T7 i, T7 i) -> T7 i -> Bool Source #isUnderflow :: (T7 i, T7 i) -> T7 i -> Bool Source #inRange :: (T7 i, T7 i) -> T7 i -> Bool Source #prev :: (T7 i, T7 i) -> T7 i -> T7 i Source #next :: (T7 i, T7 i) -> T7 i -> T7 i Source #offset :: (T7 i, T7 i) -> T7 i -> Int Source #index :: (T7 i, T7 i) -> Int -> T7 i Source #range :: (T7 i, T7 i) -> [T7 i] Source #subshape :: (Sub (T7 i) j, Index (T7 i :|: j)) => (T7 i, T7 i) -> (T7 i :|: j) -> (j, j) Source #slice :: (Sub (T7 i) j, ij ~ (T7 i :|: j), Index j) => (T7 i, T7 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T6 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T6 i, T6 i) -> Int Source #sizes :: (T6 i, T6 i) -> [Int] Source #safeElem :: (T6 i, T6 i) -> T6 i -> T6 i Source #ordBounds :: (T6 i, T6 i) -> (T6 i, T6 i) Source #defLimit :: T6 i -> Integer Source #defaultBounds :: Int -> (T6 i, T6 i) Source #isEmpty :: (T6 i, T6 i) -> Bool Source #inBounds :: (T6 i, T6 i) -> T6 i -> InBounds Source #isOverflow :: (T6 i, T6 i) -> T6 i -> Bool Source #isUnderflow :: (T6 i, T6 i) -> T6 i -> Bool Source #inRange :: (T6 i, T6 i) -> T6 i -> Bool Source #prev :: (T6 i, T6 i) -> T6 i -> T6 i Source #next :: (T6 i, T6 i) -> T6 i -> T6 i Source #offset :: (T6 i, T6 i) -> T6 i -> Int Source #index :: (T6 i, T6 i) -> Int -> T6 i Source #range :: (T6 i, T6 i) -> [T6 i] Source #subshape :: (Sub (T6 i) j, Index (T6 i :|: j)) => (T6 i, T6 i) -> (T6 i :|: j) -> (j, j) Source #slice :: (Sub (T6 i) j, ij ~ (T6 i :|: j), Index j) => (T6 i, T6 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T5 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T5 i, T5 i) -> Int Source #sizes :: (T5 i, T5 i) -> [Int] Source #safeElem :: (T5 i, T5 i) -> T5 i -> T5 i Source #ordBounds :: (T5 i, T5 i) -> (T5 i, T5 i) Source #defLimit :: T5 i -> Integer Source #defaultBounds :: Int -> (T5 i, T5 i) Source #isEmpty :: (T5 i, T5 i) -> Bool Source #inBounds :: (T5 i, T5 i) -> T5 i -> InBounds Source #isOverflow :: (T5 i, T5 i) -> T5 i -> Bool Source #isUnderflow :: (T5 i, T5 i) -> T5 i -> Bool Source #inRange :: (T5 i, T5 i) -> T5 i -> Bool Source #prev :: (T5 i, T5 i) -> T5 i -> T5 i Source #next :: (T5 i, T5 i) -> T5 i -> T5 i Source #offset :: (T5 i, T5 i) -> T5 i -> Int Source #index :: (T5 i, T5 i) -> Int -> T5 i Source #range :: (T5 i, T5 i) -> [T5 i] Source #subshape :: (Sub (T5 i) j, Index (T5 i :|: j)) => (T5 i, T5 i) -> (T5 i :|: j) -> (j, j) Source #slice :: (Sub (T5 i) j, ij ~ (T5 i :|: j), Index j) => (T5 i, T5 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T4 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T4 i, T4 i) -> Int Source #sizes :: (T4 i, T4 i) -> [Int] Source #safeElem :: (T4 i, T4 i) -> T4 i -> T4 i Source #ordBounds :: (T4 i, T4 i) -> (T4 i, T4 i) Source #defLimit :: T4 i -> Integer Source #defaultBounds :: Int -> (T4 i, T4 i) Source #isEmpty :: (T4 i, T4 i) -> Bool Source #inBounds :: (T4 i, T4 i) -> T4 i -> InBounds Source #isOverflow :: (T4 i, T4 i) -> T4 i -> Bool Source #isUnderflow :: (T4 i, T4 i) -> T4 i -> Bool Source #inRange :: (T4 i, T4 i) -> T4 i -> Bool Source #prev :: (T4 i, T4 i) -> T4 i -> T4 i Source #next :: (T4 i, T4 i) -> T4 i -> T4 i Source #offset :: (T4 i, T4 i) -> T4 i -> Int Source #index :: (T4 i, T4 i) -> Int -> T4 i Source #range :: (T4 i, T4 i) -> [T4 i] Source #subshape :: (Sub (T4 i) j, Index (T4 i :|: j)) => (T4 i, T4 i) -> (T4 i :|: j) -> (j, j) Source #slice :: (Sub (T4 i) j, ij ~ (T4 i :|: j), Index j) => (T4 i, T4 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T3 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T3 i, T3 i) -> Int Source #sizes :: (T3 i, T3 i) -> [Int] Source #safeElem :: (T3 i, T3 i) -> T3 i -> T3 i Source #ordBounds :: (T3 i, T3 i) -> (T3 i, T3 i) Source #defLimit :: T3 i -> Integer Source #defaultBounds :: Int -> (T3 i, T3 i) Source #isEmpty :: (T3 i, T3 i) -> Bool Source #inBounds :: (T3 i, T3 i) -> T3 i -> InBounds Source #isOverflow :: (T3 i, T3 i) -> T3 i -> Bool Source #isUnderflow :: (T3 i, T3 i) -> T3 i -> Bool Source #inRange :: (T3 i, T3 i) -> T3 i -> Bool Source #prev :: (T3 i, T3 i) -> T3 i -> T3 i Source #next :: (T3 i, T3 i) -> T3 i -> T3 i Source #offset :: (T3 i, T3 i) -> T3 i -> Int Source #index :: (T3 i, T3 i) -> Int -> T3 i Source #range :: (T3 i, T3 i) -> [T3 i] Source #subshape :: (Sub (T3 i) j, Index (T3 i :|: j)) => (T3 i, T3 i) -> (T3 i :|: j) -> (j, j) Source #slice :: (Sub (T3 i) j, ij ~ (T3 i :|: j), Index j) => (T3 i, T3 i) -> ij -> ((ij, ij), (j, j)) Source # (Ord i, Index i, Enum i, Bounded i) => Index (T2 i) Source # Instance detailsDefined in SDP.Index Methodssize :: (T2 i, T2 i) -> Int Source #sizes :: (T2 i, T2 i) -> [Int] Source #safeElem :: (T2 i, T2 i) -> T2 i -> T2 i Source #ordBounds :: (T2 i, T2 i) -> (T2 i, T2 i) Source #defLimit :: T2 i -> Integer Source #defaultBounds :: Int -> (T2 i, T2 i) Source #isEmpty :: (T2 i, T2 i) -> Bool Source #inBounds :: (T2 i, T2 i) -> T2 i -> InBounds Source #isOverflow :: (T2 i, T2 i) -> T2 i -> Bool Source #isUnderflow :: (T2 i, T2 i) -> T2 i -> Bool Source #inRange :: (T2 i, T2 i) -> T2 i -> Bool Source #prev :: (T2 i, T2 i) -> T2 i -> T2 i Source #next :: (T2 i, T2 i) -> T2 i -> T2 i Source #offset :: (T2 i, T2 i) -> T2 i -> Int Source #index :: (T2 i, T2 i) -> Int -> T2 i Source #range :: (T2 i, T2 i) -> [T2 i] Source #subshape :: (Sub (T2 i) j, Index (T2 i :|: j)) => (T2 i, T2 i) -> (T2 i :|: j) -> (j, j) Source #slice :: (Sub (T2 i) j, ij ~ (T2 i :|: j), Index j) => (T2 i, T2 i) -> ij -> ((ij, ij), (j, j)) Source # (Index i, Enum i, Bounded i, Index (i' :& i)) => Index ((i' :& i) :& i) Source # Instance detailsDefined in SDP.Index Methodssize :: ((i' :& i) :& i, (i' :& i) :& i) -> Int Source #sizes :: ((i' :& i) :& i, (i' :& i) :& i) -> [Int] Source #safeElem :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> (i' :& i) :& i Source #ordBounds :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i, (i' :& i) :& i) Source #defLimit :: ((i' :& i) :& i) -> Integer Source #defaultBounds :: Int -> ((i' :& i) :& i, (i' :& i) :& i) Source #unsafeIndex :: Int -> (i' :& i) :& i Source #isEmpty :: ((i' :& i) :& i, (i' :& i) :& i) -> Bool Source #inBounds :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> InBounds Source #isOverflow :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> Bool Source #isUnderflow :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> Bool Source #inRange :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> Bool Source #prev :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> (i' :& i) :& i Source #next :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> (i' :& i) :& i Source #offset :: ((i' :& i) :& i, (i' :& i) :& i) -> ((i' :& i) :& i) -> Int Source #index :: ((i' :& i) :& i, (i' :& i) :& i) -> Int -> (i' :& i) :& i Source #range :: ((i' :& i) :& i, (i' :& i) :& i) -> [(i' :& i) :& i] Source #subshape :: (Sub ((i' :& i) :& i) j, Index (((i' :& i) :& i) :|: j)) => ((i' :& i) :& i, (i' :& i) :& i) -> (((i' :& i) :& i) :|: j) -> (j, j) Source #slice :: (Sub ((i' :& i) :& i) j, ij ~ (((i' :& i) :& i) :|: j), Index j) => ((i' :& i) :& i, (i' :& i) :& i) -> ij -> ((ij, ij), (j, j)) Source # Index i => Index (E :& i) Source # Instance detailsDefined in SDP.Index Methodssize :: (E :& i, E :& i) -> Int Source #sizes :: (E :& i, E :& i) -> [Int] Source #safeElem :: (E :& i, E :& i) -> (E :& i) -> E :& i Source #ordBounds :: (E :& i, E :& i) -> (E :& i, E :& i) Source #defLimit :: (E :& i) -> Integer Source #defaultBounds :: Int -> (E :& i, E :& i) Source #isEmpty :: (E :& i, E :& i) -> Bool Source #inBounds :: (E :& i, E :& i) -> (E :& i) -> InBounds Source #isOverflow :: (E :& i, E :& i) -> (E :& i) -> Bool Source #isUnderflow :: (E :& i, E :& i) -> (E :& i) -> Bool Source #inRange :: (E :& i, E :& i) -> (E :& i) -> Bool Source #prev :: (E :& i, E :& i) -> (E :& i) -> E :& i Source #next :: (E :& i, E :& i) -> (E :& i) -> E :& i Source #offset :: (E :& i, E :& i) -> (E :& i) -> Int Source #index :: (E :& i, E :& i) -> Int -> E :& i Source #range :: (E :& i, E :& i) -> [E :& i] Source #subshape :: (Sub (E :& i) j, Index ((E :& i) :|: j)) => (E :& i, E :& i) -> ((E :& i) :|: j) -> (j, j) Source #slice :: (Sub (E :& i) j, ij ~ ((E :& i) :|: j), Index j) => (E :& i, E :& i) -> ij -> ((ij, ij), (j, j)) Source #

## Helpers

data InBounds Source #

InBounds - service type that specifies index and bounds status.

Constructors

 ER Empty range UR Underflow range IN Index in range OR Overflow range

#### Instances

Instances details
 Source # Instance detailsDefined in SDP.Index MethodsenumFrom :: InBounds -> [InBounds] #enumFromTo :: InBounds -> InBounds -> [InBounds] # Source # Instance detailsDefined in SDP.Index Methods Source # Instance detailsDefined in SDP.Index Methods Source # Instance detailsDefined in SDP.Index MethodsshowList :: [InBounds] -> ShowS #

offsetIntegral :: (Index i, Integral i) => (i, i) -> i -> Int Source #

Default offset for Integral types.

defaultBoundsUnsign :: (Index i, Bounded i) => Int -> (i, i) Source #

Default defaultBounds for unsigned types.

# Orphan instances

 Index i => Estimate (i, i) Source # Instance details Methods(<.=>) :: (i, i) -> Int -> Ordering Source #(<==>) :: Compare (i, i) Source #(.==) :: (i, i) -> Int -> Bool Source #(./=) :: (i, i) -> Int -> Bool Source #(.<=) :: (i, i) -> Int -> Bool Source #(.>=) :: (i, i) -> Int -> Bool Source #(.<) :: (i, i) -> Int -> Bool Source #(.>) :: (i, i) -> Int -> Bool Source #(.<.) :: (i, i) -> (i, i) -> Bool Source #(.>.) :: (i, i) -> (i, i) -> Bool Source #(.<=.) :: (i, i) -> (i, i) -> Bool Source #(.>=.) :: (i, i) -> (i, i) -> Bool Source #(.==.) :: (i, i) -> (i, i) -> Bool Source #(./=.) :: (i, i) -> (i, i) -> Bool Source # Index i => Nullable (i, i) Source # Instance details Methodslzero :: (i, i) Source #isNull :: (i, i) -> Bool Source #