-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Pure, type-indexed haskell vector, matrix, and tensor library.
--   
--   Pure, type-indexed haskell vector, matrix, and tensor library.
--   Features dimensionality type-checking for all operations. Generic
--   n-dimensional versions are implemented using low-level prim ops.
--   Allows ad-hoc replacement with fixed low-dimensionality vectors and
--   matrices without changing user interface. Please see the README on
--   GitHub at <a>https://github.com/achirkin/easytensor#readme</a>
@package easytensor
@version 2.1.0.0


-- | Facilities for converting Haskell data to and from raw bytes.
--   
--   The main purpose of this module is to support the implementation of
--   the <tt>DataFrame</tt> <a>Backend</a>. However, it also comes very
--   useful for writing FFI. To that end, the <a>PrimBytes</a> class is
--   similar to the <a>Storable</a> class: it provides means to write your
--   data to and read from a raw memory area. Though, it is more flexible
--   in that it can work with both, foreign pointers and primitive byte
--   arrays, and it provides means to get data field offsets by their
--   selector names. On top of that, a <a>PrimBytes</a> instance can be
--   derived via the <a>Generic</a> machinery.
--   
--   A derived <a>PrimBytes</a> instance tries to pack the data as dense as
--   possible, while respecting the alignment requirements. In all cases
--   known to me, the resulting data layout coincides with a corresponding
--   C struct, allowing to marshal the data without any boilerplate.
--   However, this is not guaranteed, but you can write a <a>PrimBytes</a>
--   instance manually if necessary (and report an issue plz).
--   
--   <b>Note about alignment, size, and padding of the data.</b> There are
--   two basic sanity assumptions about these, which are not checked in
--   this module at all:
--   
--   <ul>
--   <li>the alignment is always a power of 2;</li>
--   <li>the size is always rounded up to a multiple of the alignment.</li>
--   </ul>
--   
--   Generated instances of <a>PrimBytes</a> meet these assumptions if all
--   components of a data meet these assumptions too. You are strongly
--   advised to provide all byte offset arguments to the <a>PrimBytes</a>
--   functions respecting the alignment of the data; otherwise, the data
--   may be written or read incorrectly.
module Numeric.PrimBytes

-- | Defines how to read and write your data to and from Haskell unboxed
--   byte arrays and plain pointers.
--   
--   Similarly to <a>Storable</a>, this class provides functions to get the
--   size and alignment of a data via phantom arguments. Thus, the size and
--   alignment of the data must not depend on the data content (they depend
--   only on the type of the data). In particular, this means that
--   dynamically sized structures like Haskell lists or maps are not
--   allowed.
--   
--   This module provides default implementations for all methods of this
--   class via <a>Generic</a>. Hence, to make your data an instance of
--   <tt>PrimBytes</tt>, it is sufficient to write the instance head:
--   
--   <pre>
--   data MyData a b = ...
--     deriving Generic
--   
--   instance (PrimBytes a, PrimBytes b) =&gt; PrimBytes (MyData a b)
--   </pre>
--   
--   .. or use the <tt>DeriveAnyClass</tt> extension to make it even
--   shorter:
--   
--   <pre>
--   data MyData a b = ...
--     deriving (Generic, PrimBytes)
--   </pre>
--   
--   The derived instance tries to pack the data as dense as possible, but
--   sometimes it is better to write the instance by hand. If a derived
--   type has more than one constructor, the derived instance puts a
--   <tt>Word32</tt> tag at the beginning of the byte representation. All
--   fields of a constructor are packed in a C-like fashion next to each
--   other, while respecting their alignments.
class PrimTagged a => PrimBytes a where {
    
    -- | List of field names.
    --   
    --   It is used to get field offsets using <a>byteFieldOffset</a> function.
    --   
    --   A Generic-derived instance has this list non-empty only if two obvious
    --   conditions are met:
    --   
    --   <ol>
    --   <li>The data has only one constructor.</li>
    --   <li>The data uses record syntax to define its fields.</li>
    --   </ol>
    type family PrimFields a :: [Symbol];
    type PrimFields a = GPrimFields (Rep a);
}

-- | Store content of a data type in a primitive byte array (should be used
--   together with <tt>byteOffset</tt> function).
--   
--   Note, the default implementation of this function returns a not pinned
--   array, which is aligned to <tt>8</tt>. Thus, it ignores the alignment
--   of the underlying data type if it is larger. However, alignment
--   calculation still makes sense for data types that are smaller than
--   <tt>8</tt> bytes: they are packed more densely.
getBytes :: PrimBytes a => a -> ByteArray#

-- | Store content of a data type in a primitive byte array (should be used
--   together with <tt>byteOffset</tt> function).
--   
--   In contrast to <a>getBytes</a>, this function returns a pinned byte
--   array, aligned to the <tt>byteAlign</tt> bytes of this data.
--   
--   Note, GC guarantees not to move the created array. While this is very
--   useful sometimes, it incurs a certain performance penalty.
getBytesPinned :: PrimBytes a => a -> ByteArray#

-- | Load content of a data type from a primitive byte array given an
--   offset in bytes.
fromBytes :: PrimBytes a => Int# -> ByteArray# -> a

-- | Read data from a mutable byte array given an offset in bytes.
readBytes :: PrimBytes a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)

-- | Write data into a mutable byte array at a given position (offset in
--   bytes).
writeBytes :: PrimBytes a => MutableByteArray# s -> Int# -> a -> State# s -> State# s

-- | Read data from a specified address.
readAddr :: PrimBytes a => Addr# -> State# s -> (# State# s, a #)

-- | Write data to a specified address.
writeAddr :: PrimBytes a => a -> Addr# -> State# s -> State# s

-- | Size of a data type in bytes. It should be a multiple of
--   <tt>byteAlign</tt> for indexing functions to operate correctly.
--   
--   Implementation of this function must not inspect the argument value; a
--   caller may provide <tt>undefined</tt> in place of the argument.
byteSize :: PrimBytes a => a -> Int#

-- | Alignment of a data type in bytes. <tt>byteOffset</tt> should be
--   multiple of this value.
--   
--   Implementation of this function must not inspect the argument value; a
--   caller may provide <tt>undefined</tt> in place of the argument.
byteAlign :: PrimBytes a => a -> Int#

-- | Offset of the data in a byte array used to store the data, measured in
--   bytes. Should be used together with <tt>getBytes</tt> function. Unless
--   in case of special data types represented by ByteArrays, it is equal
--   to zero.
--   
--   Implementation of this function may inspect the argument value; a
--   caller must not provide <tt>undefined</tt> in place of the argument.
byteOffset :: PrimBytes a => a -> Int#

-- | Offset of a data record within the data type in bytes.
--   
--   Implementation of this function must not inspect the argument value; a
--   caller may provide <tt>undefined</tt> in place of the argument.
--   
--   The default (generic) implementation of this fucntion looks for the
--   leftmost occurrence of a given field name (in case of multiple
--   constructors). If a field with the given name is not found, it returns
--   <tt>-1</tt>, but this is not possible thanks to <tt>Elem name
--   (PrimFields a)</tt> constraint.
byteFieldOffset :: (PrimBytes a, Elem name (PrimFields a), KnownSymbol name) => Proxy# name -> a -> Int#

-- | Index array given an element offset (which is <tt>byteSize a</tt> and
--   should be a multiple of <tt>byteAlign a</tt>).
indexArray :: PrimBytes a => ByteArray# -> Int# -> a

-- | Read a mutable array given an element offset (which is <tt>byteSize
--   a</tt> and should be a multiple of <tt>byteAlign a</tt>).
readArray :: PrimBytes a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)

-- | Write a mutable array given an element offset (which is <tt>byteSize
--   a</tt> and should be a multiple of <tt>byteAlign a</tt>).
writeArray :: PrimBytes a => MutableByteArray# s -> Int# -> a -> State# s -> State# s

-- | Load content of a data type from a primitive byte array given an
--   offset in bytes.
fromBytes :: (PrimBytes a, Generic a, GPrimBytes (Rep a)) => Int# -> ByteArray# -> a

-- | Read data from a mutable byte array given an offset in bytes.
readBytes :: (PrimBytes a, Generic a, GPrimBytes (Rep a)) => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)

-- | Write data into a mutable byte array at a given position (offset in
--   bytes).
writeBytes :: (PrimBytes a, Generic a, GPrimBytes (Rep a)) => MutableByteArray# s -> Int# -> a -> State# s -> State# s

-- | Read data from a specified address.
readAddr :: (PrimBytes a, Generic a, GPrimBytes (Rep a)) => Addr# -> State# s -> (# State# s, a #)

-- | Write data to a specified address.
writeAddr :: (PrimBytes a, Generic a, GPrimBytes (Rep a)) => a -> Addr# -> State# s -> State# s

-- | Size of a data type in bytes. It should be a multiple of
--   <tt>byteAlign</tt> for indexing functions to operate correctly.
--   
--   Implementation of this function must not inspect the argument value; a
--   caller may provide <tt>undefined</tt> in place of the argument.
byteSize :: (PrimBytes a, Generic a, GPrimBytes (Rep a)) => a -> Int#

-- | Alignment of a data type in bytes. <tt>byteOffset</tt> should be
--   multiple of this value.
--   
--   Implementation of this function must not inspect the argument value; a
--   caller may provide <tt>undefined</tt> in place of the argument.
byteAlign :: (PrimBytes a, Generic a, GPrimBytes (Rep a)) => a -> Int#

-- | Offset of a data record within the data type in bytes.
--   
--   Implementation of this function must not inspect the argument value; a
--   caller may provide <tt>undefined</tt> in place of the argument.
--   
--   The default (generic) implementation of this fucntion looks for the
--   leftmost occurrence of a given field name (in case of multiple
--   constructors). If a field with the given name is not found, it returns
--   <tt>-1</tt>, but this is not possible thanks to <tt>Elem name
--   (PrimFields a)</tt> constraint.
byteFieldOffset :: (PrimBytes a, Generic a, GPrimBytes (Rep a), KnownSymbol name) => Proxy# name -> a -> Int#

-- | A wrapper on <a>byteSize</a>
bSizeOf :: (PrimBytes a, Num b) => a -> b

-- | A wrapper on <a>byteAlign</a>
bAlignOf :: (PrimBytes a, Num b) => a -> b

-- | A wrapper on <a>byteFieldOffset</a>.
bFieldOffsetOf :: forall (name :: Symbol) (a :: Type) (b :: Type). (PrimBytes a, Elem name (PrimFields a), KnownSymbol name, Num b) => a -> b

-- | Same as <a>peekElemOff</a>: peek an element <tt>a</tt> by the offset
--   measured in <tt>byteSize a</tt>.
--   
--   Note: the size of the element must be a multiple of its alignment for
--   a correct operation of this function.
bPeekElemOff :: forall (a :: Type). PrimBytes a => Ptr a -> Int -> IO a

-- | Same as <a>pokeElemOff</a>: poke an element <tt>a</tt> by the offset
--   measured in <tt>byteSize a</tt>.
--   
--   Note: the size of the element must be a multiple of its alignment for
--   a correct operation of this function.
bPokeElemOff :: forall (a :: Type). PrimBytes a => Ptr a -> Int -> a -> IO ()

-- | Same as <a>peekByteOff</a>: peek an element <tt>a</tt> by the offset
--   measured in bytes.
--   
--   Note: you'd better be sure the address is a multiple of the data
--   alignment (<a>peek</a>).
bPeekByteOff :: forall (a :: Type) (b :: Type). PrimBytes a => Ptr b -> Int -> IO a

-- | Same as <a>pokeByteOff</a>: poke an element <tt>a</tt> by the offset
--   measured in bytes.
--   
--   Note: you'd better be sure the address is a multiple of the data
--   alignment (<a>peek</a>).
bPokeByteOff :: forall (a :: Type) (b :: Type). PrimBytes a => Ptr b -> Int -> a -> IO ()

-- | Same as <a>peek</a>: read a data from a pointer.
--   
--   Note: you'd better be sure the address is a multiple of the data
--   alignment (<a>peek</a>).
bPeek :: forall (a :: Type). PrimBytes a => Ptr a -> IO a

-- | Same as <a>poke</a>: write a data to a pointer.
--   
--   Note: you'd better be sure the address is a multiple of the data
--   alignment (<a>peek</a>).
bPoke :: forall (a :: Type). PrimBytes a => Ptr a -> a -> IO ()

-- | Find out which basic GHC type it is at runtime. It is used for
--   <tt>DataFrame</tt> backend specialization: by matching a <tt>PrimTag
--   a</tt> against its constructors, you can figure out a specific
--   implementation of <tt>Backend a ds</tt> (e.g. whether this is a
--   specialized float array, or a generic polymorphic array). For
--   non-basic types it defaults to <a>PTagOther</a>.
data PrimTag a
[PTagFloat] :: PrimTag Float
[PTagDouble] :: PrimTag Double
[PTagInt] :: PrimTag Int
[PTagInt8] :: PrimTag Int8
[PTagInt16] :: PrimTag Int16
[PTagInt32] :: PrimTag Int32
[PTagInt64] :: PrimTag Int64
[PTagWord] :: PrimTag Word
[PTagWord8] :: PrimTag Word8
[PTagWord16] :: PrimTag Word16
[PTagWord32] :: PrimTag Word32
[PTagWord64] :: PrimTag Word64
[PTagChar] :: PrimTag Char
[PTagPtr] :: PrimTag (Ptr a)
[PTagOther] :: PrimTag a

-- | This function allows to find out a type by comparing its tag. This is
--   needed for backend specialization, to infer array instances. For
--   non-basic types it defaults to <a>PTagOther</a>.
primTag :: PrimBytes a => a -> PrimTag a
instance GHC.Show.Show (Numeric.PrimBytes.PrimTag a)
instance Numeric.PrimBytes.PrimBytes a => Numeric.PrimBytes.GPrimBytes (GHC.Generics.K1 i a)
instance Numeric.PrimBytes.PrimBytes GHC.Types.Word
instance Numeric.PrimBytes.PrimBytes GHC.Types.Int
instance Numeric.PrimBytes.PrimBytes GHC.Types.Float
instance Numeric.PrimBytes.PrimBytes GHC.Types.Double
instance Numeric.PrimBytes.PrimBytes (GHC.Ptr.Ptr a)
instance Numeric.PrimBytes.PrimBytes GHC.Int.Int8
instance Numeric.PrimBytes.PrimBytes GHC.Int.Int16
instance Numeric.PrimBytes.PrimBytes GHC.Int.Int32
instance Numeric.PrimBytes.PrimBytes GHC.Int.Int64
instance Numeric.PrimBytes.PrimBytes GHC.Word.Word8
instance Numeric.PrimBytes.PrimBytes GHC.Word.Word16
instance Numeric.PrimBytes.PrimBytes GHC.Word.Word32
instance Numeric.PrimBytes.PrimBytes GHC.Word.Word64
instance Numeric.PrimBytes.PrimBytes GHC.Types.Char
instance forall k (x :: k). Numeric.PrimBytes.PrimBytes (Numeric.Dimensions.Idx.Idx x)
instance forall k (xs :: [k]). Numeric.TypedList.RepresentableList xs => Numeric.PrimBytes.PrimBytes (Numeric.Dimensions.Idx.Idxs xs)
instance (Numeric.TypedList.RepresentableList xs, Data.Type.List.All Numeric.PrimBytes.PrimBytes xs) => Numeric.PrimBytes.PrimBytes (Numeric.Tuple.Lazy.Tuple xs)
instance (Numeric.TypedList.RepresentableList xs, Data.Type.List.All Numeric.PrimBytes.PrimBytes xs) => Numeric.PrimBytes.PrimBytes (Numeric.Tuple.Strict.Tuple xs)
instance Numeric.PrimBytes.PrimBytes ()
instance Numeric.PrimBytes.PrimBytes a => Numeric.PrimBytes.PrimBytes (GHC.Maybe.Maybe a)
instance (Numeric.PrimBytes.PrimBytes a, Numeric.PrimBytes.PrimBytes b) => Numeric.PrimBytes.PrimBytes (Data.Either.Either a b)
instance (Numeric.PrimBytes.PrimBytes a, Numeric.PrimBytes.PrimBytes b) => Numeric.PrimBytes.PrimBytes (a, b)
instance (Numeric.PrimBytes.PrimBytes a, Numeric.PrimBytes.PrimBytes b, Numeric.PrimBytes.PrimBytes c) => Numeric.PrimBytes.PrimBytes (a, b, c)
instance (Numeric.PrimBytes.PrimBytes a, Numeric.PrimBytes.PrimBytes b, Numeric.PrimBytes.PrimBytes c, Numeric.PrimBytes.PrimBytes d) => Numeric.PrimBytes.PrimBytes (a, b, c, d)
instance (Numeric.PrimBytes.PrimBytes a, Numeric.PrimBytes.PrimBytes b, Numeric.PrimBytes.PrimBytes c, Numeric.PrimBytes.PrimBytes d, Numeric.PrimBytes.PrimBytes e) => Numeric.PrimBytes.PrimBytes (a, b, c, d, e)
instance (Numeric.PrimBytes.PrimBytes a, Numeric.PrimBytes.PrimBytes b, Numeric.PrimBytes.PrimBytes c, Numeric.PrimBytes.PrimBytes d, Numeric.PrimBytes.PrimBytes e, Numeric.PrimBytes.PrimBytes f) => Numeric.PrimBytes.PrimBytes (a, b, c, d, e, f)
instance (Numeric.PrimBytes.PrimBytes a, Numeric.PrimBytes.PrimBytes b, Numeric.PrimBytes.PrimBytes c, Numeric.PrimBytes.PrimBytes d, Numeric.PrimBytes.PrimBytes e, Numeric.PrimBytes.PrimBytes f, Numeric.PrimBytes.PrimBytes g) => Numeric.PrimBytes.PrimBytes (a, b, c, d, e, f, g)
instance Numeric.PrimBytes.PrimTagged a
instance Numeric.PrimBytes.PrimTagged GHC.Types.Float
instance Numeric.PrimBytes.PrimTagged GHC.Types.Double
instance Numeric.PrimBytes.PrimTagged GHC.Types.Int
instance Numeric.PrimBytes.PrimTagged GHC.Int.Int8
instance Numeric.PrimBytes.PrimTagged GHC.Int.Int16
instance Numeric.PrimBytes.PrimTagged GHC.Int.Int32
instance Numeric.PrimBytes.PrimTagged GHC.Int.Int64
instance Numeric.PrimBytes.PrimTagged GHC.Types.Word
instance Numeric.PrimBytes.PrimTagged GHC.Word.Word8
instance Numeric.PrimBytes.PrimTagged GHC.Word.Word16
instance Numeric.PrimBytes.PrimTagged GHC.Word.Word32
instance Numeric.PrimBytes.PrimTagged GHC.Word.Word64
instance Numeric.PrimBytes.PrimTagged GHC.Types.Char
instance Numeric.PrimBytes.PrimTagged (GHC.Ptr.Ptr a)
instance Numeric.PrimBytes.GPrimBytes GHC.Generics.V1
instance Numeric.PrimBytes.GPrimBytes GHC.Generics.U1
instance forall k (f :: k -> *) (sn :: GHC.Types.Symbol) (a :: GHC.Generics.SourceUnpackedness) (b :: GHC.Generics.SourceStrictness) (c :: GHC.Generics.DecidedStrictness). (Numeric.PrimBytes.GPrimBytes f, GHC.TypeLits.KnownSymbol sn) => Numeric.PrimBytes.GPrimBytes (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel ('GHC.Maybe.Just sn) a b c) f)
instance forall k (f :: k -> *) i (c :: GHC.Generics.Meta). Numeric.PrimBytes.GPrimBytes f => Numeric.PrimBytes.GPrimBytes (GHC.Generics.M1 i c f)
instance forall k (f :: k -> *) (g :: k -> *). (Numeric.PrimBytes.GPrimBytes f, Numeric.PrimBytes.GPrimBytes g) => Numeric.PrimBytes.GPrimBytes (f GHC.Generics.:*: g)
instance forall k (f :: k -> *) (g :: k -> *). (Numeric.PrimBytes.GPrimBytes f, Numeric.PrimBytes.GPrimBytes g) => Numeric.PrimBytes.GPrimBytes (f GHC.Generics.:+: g)
instance Numeric.PrimBytes.GPrimBytes (GHC.Generics.URec GHC.Types.Word)
instance Numeric.PrimBytes.GPrimBytes (GHC.Generics.URec GHC.Types.Int)
instance Numeric.PrimBytes.GPrimBytes (GHC.Generics.URec GHC.Types.Float)
instance Numeric.PrimBytes.GPrimBytes (GHC.Generics.URec GHC.Types.Double)
instance Numeric.PrimBytes.GPrimBytes (GHC.Generics.URec GHC.Types.Char)
instance Numeric.PrimBytes.GPrimBytes (GHC.Generics.URec (GHC.Ptr.Ptr ()))

module Numeric.DataFrame.Internal.PrimArray
class PrimBytes t => PrimArray t a | a -> t

-- | Broadcast element into array
--   
--   Warning: do not use this function at the call site; use
--   <a>broadcast</a> instead. Otherwise you will miss some rewrite rules.
broadcast# :: PrimArray t a => t -> a

-- | Index an array given an offset
ix# :: PrimArray t a => Int# -> a -> t

-- | Generate an array using an accumulator funtion
gen# :: PrimArray t a => CumulDims -> (s -> (# s, t #)) -> s -> (# s, a #)

-- | update a single element in an array given an offset
upd# :: PrimArray t a => CumulDims -> Int# -> t -> a -> a

-- | If the array is represented as a single broadcasted value, return this
--   this value. Otherwise, return the full array content:
--   <tt>CumulDims</tt>, array offset (elements), byte array with the
--   content.
--   
--   Warning: never use this function directly. Use <a>withArrayContent</a>
--   instead. There is a bug in GHC 8.6, such that certain optimizations
--   (probably, instance specialization/rewrite rules) break the code,
--   which is only observable at runtime. The effect is that the content of
--   a <a>ByteArray#</a> becomes a garbage. The workaround is to use a
--   non-inlinable wrapper to disable these optimizations. In addition, the
--   wrapper function has some rewrite rules, which can potentially improve
--   performance with other GHC versions.

-- | <i>Warning: Please, use withArrayContent instead.</i>
withArrayContent# :: forall (rep :: RuntimeRep) (r :: TYPE rep). PrimArray t a => (t -> r) -> (CumulDims -> Int# -> ByteArray# -> r) -> a -> r

-- | Offset of an array as a number of elements
offsetElems :: PrimArray t a => a -> Int#

-- | Normally, this returns a cumulative <tt>totalDim</tt>s. However, if a
--   particular implementation does not have the dimensionality
--   information, it cannot return <tt>CumulDims</tt>; In this case, it is
--   a sign that all elements of an array are same. Thus, it is possible to
--   return the single element value instead.
--   
--   Note, this function returns the only unique element only if it is a
--   such by construction (there is no equality checks involved).
uniqueOrCumulDims :: PrimArray t a => a -> Either t CumulDims

-- | Define an array by its offset and cumulative dims in a ByteArray. Both
--   offset and dims are given in element number (not in bytes).
--   
--   Warning: never use this function directly. Use <a>fromElems</a>
--   instead. There is a bug in GHC 8.6, such that certain optimizations
--   (probably, instance specialization/rewrite rules) break the code,
--   which is only observable at runtime. The effect is that the content of
--   a <a>ByteArray#</a> becomes a garbage. The workaround is to use a
--   non-inlinable wrapper to disable these optimizations. In addition, the
--   wrapper function has some rewrite rules, which can potentially improve
--   performance with other GHC versions.

-- | <i>Warning: Please, use fromElems instead.</i>
fromElems# :: PrimArray t a => CumulDims -> Int# -> ByteArray# -> a

-- | Given <tt>Dims ns</tt>, <tt>CumulativeDims</tt> is a list of length
--   <tt>Length ns + 1</tt>; which cumulative <tt>totalDim</tt> accumulated
--   on the right. In particular, its first element is <tt>totalDim
--   ds</tt>, its last element is always is always <tt>1</tt>.
newtype CumulDims
CumulDims :: [Word] -> CumulDims
[unCumulDims] :: CumulDims -> [Word]

-- | Calculate cumulative dims
cumulDims :: Dims (ns :: [k]) -> CumulDims

-- | Get the total number of elements
cdTotalDim :: CumulDims -> Word
cdTotalDim# :: CumulDims -> Int#

-- | Calculate offset of an Idxs
--   
--   Note, you can take offset of subspace with CumulDims of larger space -
--   very convenient!
--   
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
cdIx :: CumulDims -> Idxs ns -> Int

-- | Calculate offset of an Idxs.
--   
--   Also check if the last index plus dimVal of subN is not bigger than
--   the corresponding dim inside CumulDims; throw an <a>OutOfDimBounds</a>
--   otherwise.
--   
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
cdIxSub :: CumulDims -> Idxs (ns +: idxN) -> Dim subN -> Int

-- | Calculate offset of an Idxs and return remaining CumulDims.
--   
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
getOffAndSteps :: Int -> CumulDims -> Idxs ns -> (Int, CumulDims)

-- | Calculate offset of an Idxs and return remaining CumulDims.
--   
--   Also check if the last index plus dimVal of subN is not bigger than
--   the corresponding dim inside CumulDims; throw an <a>OutOfDimBounds</a>
--   otherwise.
--   
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
getOffAndStepsSub :: Int -> CumulDims -> Idxs (ns +: idxN) -> Dim subN -> (Int, CumulDims)

-- | Same as <a>cdIx</a>, but safe; returns <tt>Nothing</tt> if out of
--   bounds.
cdIxM :: CumulDims -> Idxs ns -> Maybe Int

-- | Same as <a>getOffAndSteps</a>, but safe; returns <tt>Nothing</tt> if
--   out of bounds. Trims the first (slicing) dimension of the returned
--   CumulDims to fit the original dataframe if necessary.
getOffAndStepsM :: Int -> CumulDims -> Idxs ns -> Maybe (Int, CumulDims)

-- | Same as <a>getOffAndStepsSub</a>, but safe; returns <tt>Nothing</tt>
--   if out of bounds. Trims the first (slicing) dimension of the returned
--   CumulDims to fit the original dataframe if necessary.
getOffAndStepsSubM :: Int -> CumulDims -> Idxs (ns +: idxN) -> Dim subN -> Maybe (Int, CumulDims)

-- | Index array by an integer offset (starting from 0).
ixOff :: PrimArray t a => Int -> a -> t

-- | Construct an array from a flat list and <tt>Dims</tt>; Be careful!
--   <tt>ns</tt> depends on <tt>a</tt>, but this is not reflected in types
--   and is not checked at runtime.
unsafeFromFlatList :: PrimArray t a => Dims ns -> t -> [t] -> a

-- | Try to get <tt>CumulDims</tt> from an array, and create it using
--   <tt>Dims</tt> if failed.
getSteps :: PrimArray t a => Dims (ns :: [k]) -> a -> CumulDims

-- | Get <tt>Dims</tt> by "de-accumulating" <tt>CumulDims</tt>.
fromSteps :: CumulDims -> SomeDims

-- | If the array is represented as a single broadcasted value, return this
--   this value. Otherwise, return the full array content:
--   <tt>CumulDims</tt>, array offset (elements), byte array with the
--   content.
withArrayContent :: forall (t :: Type) (a :: Type) (rep :: RuntimeRep) (r :: TYPE rep). PrimArray t a => (t -> r) -> (CumulDims -> Int# -> ByteArray# -> r) -> a -> r

-- | Define an array by its offset and cumulative dims in a ByteArray. Both
--   offset and dims are given in element number (not in bytes).
--   
--   It is better to use this function instead of <tt>fromBytes</tt> to
--   avoid recalculating <tt>CumulDims</tt> for implementations that
--   require it.
fromElems :: forall (t :: Type) (a :: Type). PrimArray t a => CumulDims -> Int# -> ByteArray# -> a

-- | Broadcast element into array
broadcast :: forall (t :: Type) (a :: Type). PrimArray t a => t -> a
instance GHC.Show.Show Numeric.DataFrame.Internal.PrimArray.CumulDims
instance GHC.Base.Semigroup Numeric.DataFrame.Internal.PrimArray.CumulDims
instance GHC.Base.Monoid Numeric.DataFrame.Internal.PrimArray.CumulDims

module Numeric.Basics

-- | &lt;math&gt;
pattern M_E :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_LOG2E :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_LOG10E :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_LN2 :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_LN10 :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_SQRT2 :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_SQRT1_2 :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_PI :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_PI_2 :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_PI_3 :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_PI_4 :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_1_PI :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_2_PI :: (Eq a, Fractional a) => Fractional a => a

-- | &lt;math&gt;
pattern M_2_SQRTPI :: (Eq a, Fractional a) => Fractional a => a

-- | Define a meaningful precision for complex floating-point operations.
class (Eq a, Floating a) => Epsilon a

-- | A small positive number that depends on the type of <tt>a</tt>.
--   Compare your values to <tt>epsilon</tt> to tell if they are near zero.
epsilon :: Epsilon a => a

-- | A small positive number that depends on the type of <tt>a</tt>.
pattern M_EPS :: Epsilon a => a

-- | Extra functions for <a>Real</a> types.
class (Real a, PrimBytes a) => RealExtras a

-- | <tt>copysign x y</tt> returns a value with the magnitude of x and the
--   sign of y.
--   
--   NB: in future, this function is to reimplemented using primops and
--   should behave the same way as its C analogue.
copysign :: RealExtras a => a -> a -> a

-- | Extra functions for <a>RealFrac</a> types.
class (Epsilon a, RealExtras a, RealFloat a) => RealFloatExtras a

-- | &lt;math&gt;.
--   
--   NB: in future, this function is to reimplemented using primops and
--   should behave the same way as its C analogue.
hypot :: RealFloatExtras a => a -> a -> a

-- | Maximum finite number representable by this FP type.
maxFinite :: RealFloatExtras a => a

-- | Negate if <tt>False</tt>. This is a useful alternative to
--   <a>signum</a>, when <tt>signum 0 == 0</tt> causing some troubles.
negateUnless :: Num t => Bool -> t -> t

-- | This is just an alias for the <a>HasCallStack</a> constraint. It
--   servers two goals:
--   
--   <ol>
--   <li>Document functions that use iterative methods and can fail
--   (supposedly in extremely rare cases).</li>
--   <li>Provide a call stack in case of failure.</li>
--   </ol>
--   
--   Use <a>tooManyIterations</a> function where necessary if you implement
--   an iterative algorithm and annotate your implementation function with
--   <a>IterativeMethod</a> constraint.
type IterativeMethod = HasCallStack

-- | Typically, this exception can occur in an iterative algorithm; when
--   the number of iterations exceeds a pre-defined limit, but the stop
--   condition is not fulfilled.
--   
--   Use the <a>IterativeMethod</a> constraint to annotate functions that
--   throw this exception.
data TooManyIterations

-- | Throw a <a>TooManyIterations</a> exception.
tooManyIterations :: IterativeMethod => String -> a
instance GHC.Classes.Eq Numeric.Basics.TooManyIterations
instance GHC.Classes.Ord Numeric.Basics.TooManyIterations
instance GHC.Show.Show Numeric.Basics.TooManyIterations
instance GHC.Exception.Type.Exception Numeric.Basics.TooManyIterations
instance Numeric.Basics.RealFloatExtras GHC.Types.Float
instance Numeric.Basics.RealFloatExtras GHC.Types.Double
instance Numeric.Basics.RealExtras GHC.Types.Int
instance Numeric.Basics.RealExtras GHC.Int.Int8
instance Numeric.Basics.RealExtras GHC.Int.Int16
instance Numeric.Basics.RealExtras GHC.Int.Int32
instance Numeric.Basics.RealExtras GHC.Int.Int64
instance Numeric.Basics.RealExtras GHC.Types.Word
instance Numeric.Basics.RealExtras GHC.Word.Word8
instance Numeric.Basics.RealExtras GHC.Word.Word16
instance Numeric.Basics.RealExtras GHC.Word.Word32
instance Numeric.Basics.RealExtras GHC.Word.Word64
instance Numeric.Basics.RealExtras GHC.Types.Float
instance Numeric.Basics.RealExtras GHC.Types.Double
instance Numeric.Basics.Epsilon GHC.Types.Double
instance Numeric.Basics.Epsilon GHC.Types.Float


-- | Compare product types -- partial order.
module Numeric.ProductOrd

-- | Partial order for comparing product types -- <a>product order</a>.
class ProductOrder a

-- | Same as <a>compare</a>, but may return <tt>Incomparable</tt>.
cmp :: ProductOrder a => a -> a -> PartialOrdering

-- | Similar to <a>Ordering</a>, but may be <tt>Incomparable</tt>.
data PartialOrdering
PLT :: PartialOrdering
PEQ :: PartialOrdering
PGT :: PartialOrdering
Incomparable :: PartialOrdering

-- | Extend <a>Ordering</a> with <tt>Incomparable</tt> option.
fromOrdering :: Ordering -> PartialOrdering
instance GHC.Enum.Bounded Numeric.ProductOrd.PartialOrdering
instance GHC.Enum.Enum Numeric.ProductOrd.PartialOrdering
instance GHC.Generics.Generic Numeric.ProductOrd.PartialOrdering
instance Data.Data.Data Numeric.ProductOrd.PartialOrdering
instance GHC.Read.Read Numeric.ProductOrd.PartialOrdering
instance GHC.Show.Show Numeric.ProductOrd.PartialOrdering
instance GHC.Classes.Ord Numeric.ProductOrd.PartialOrdering
instance GHC.Classes.Eq Numeric.ProductOrd.PartialOrdering
instance forall k (f :: k -> *) (xs :: [k]). Data.Type.List.All GHC.Classes.Ord (Data.Type.List.Map f xs) => Numeric.ProductOrd.ProductOrder (Numeric.TypedList.TypedList f xs)
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2) => Numeric.ProductOrd.ProductOrder (a1, a2)
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3) => Numeric.ProductOrd.ProductOrder (a1, a2, a3)
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4) => Numeric.ProductOrd.ProductOrder (a1, a2, a3, a4)
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5) => Numeric.ProductOrd.ProductOrder (a1, a2, a3, a4, a5)
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6) => Numeric.ProductOrd.ProductOrder (a1, a2, a3, a4, a5, a6)
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7) => Numeric.ProductOrd.ProductOrder (a1, a2, a3, a4, a5, a6, a7)
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7, GHC.Classes.Ord a8) => Numeric.ProductOrd.ProductOrder (a1, a2, a3, a4, a5, a6, a7, a8)
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7, GHC.Classes.Ord a8, GHC.Classes.Ord a9) => Numeric.ProductOrd.ProductOrder (a1, a2, a3, a4, a5, a6, a7, a8, a9)
instance GHC.Base.Semigroup Numeric.ProductOrd.PartialOrdering
instance GHC.Base.Monoid Numeric.ProductOrd.PartialOrdering


-- | Compare product types using non-transitive <a>Ord</a> instances:
--   
--   <ul>
--   <li>&lt;math&gt; and &lt;math&gt; <b>does not mean</b>
--   &lt;math&gt;;</li>
--   <li>but, if nor &lt;math&gt; neither &lt;math&gt;, then
--   &lt;math&gt;.</li>
--   </ul>
--   
--   To remind yourself that <a>ProductOrd</a> is not fully faithful, you
--   may import it qualified, e.g.
--   
--   <pre>
--   import qualified Numeric.ProductOrd.NonTransitive as NonTransitive
--   </pre>
module Numeric.ProductOrd.NonTransitive

-- | Redefine <a>Ord</a> instance for a type which is a cartesian product
--   -- as a partial <b><a>product order</a></b>.
--   
--   Since vanilla Haskell <a>Ord</a> class is always about total order,
--   <tt>ProductOrd</tt> instance is not particularly correct. However, it
--   turns out to be very useful for comparing vector or tuple-like types.
--   
--   The implementation of <a>ProductOrd</a> in this module workarounds
--   this by using a <b>non-transitive <a>Eq</a> instance</b>: &lt;math&gt;
--   
--   Another inconsistency with the Haskell Report is the <a>min</a> and
--   <a>max</a> functions; these are simply element-wise minimum and
--   maximum here. Thus, these instances preserve important properties like
--   <tt>min a b &lt;= a &amp;&amp; min a b &lt;= b</tt>, but do not
--   preserve a property that <tt>min a b == a || min a b == b</tt>.
--   
--   All of this is really useful in geometry applications and for
--   calculating things like <a>Pareto dominance</a>, but should be used
--   with care. Remember about this if you want to put a
--   <tt>ProductOrd</tt> into a <tt>Set</tt> or a <tt>Map</tt>!
newtype ProductOrd a
ProductOrd :: a -> ProductOrd a
[getProductOrd] :: ProductOrd a -> a

-- | Treat <a>Incomparable</a> as EQ (non-transitive equality).
toOrdering :: PartialOrdering -> Ordering
instance Data.Traversable.Traversable Numeric.ProductOrd.NonTransitive.ProductOrd
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Float.Floating a => GHC.Float.Floating (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Enum.Bounded a => GHC.Enum.Bounded (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Num.Num a => GHC.Num.Num (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Generics.Generic1 Numeric.ProductOrd.NonTransitive.ProductOrd
instance GHC.Generics.Generic (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance Data.Data.Data a => Data.Data.Data (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Read.Read a => GHC.Read.Read (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance GHC.Show.Show a => GHC.Show.Show (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd a), GHC.Real.Integral a) => GHC.Real.Integral (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd a), Data.Bits.Bits a) => Data.Bits.Bits (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd a), Data.Bits.FiniteBits a) => Data.Bits.FiniteBits (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd a), GHC.Real.Real a) => GHC.Real.Real (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd a), GHC.Real.RealFrac a) => GHC.Real.RealFrac (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd a), GHC.Float.RealFloat a) => GHC.Float.RealFloat (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance Data.Foldable.Foldable Numeric.ProductOrd.NonTransitive.ProductOrd
instance GHC.Base.Functor Numeric.ProductOrd.NonTransitive.ProductOrd
instance GHC.Base.Applicative Numeric.ProductOrd.NonTransitive.ProductOrd
instance GHC.Base.Monad Numeric.ProductOrd.NonTransitive.ProductOrd
instance Control.Monad.Fix.MonadFix Numeric.ProductOrd.NonTransitive.ProductOrd
instance Control.Monad.Zip.MonadZip Numeric.ProductOrd.NonTransitive.ProductOrd
instance GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd a) => GHC.Classes.Eq (Numeric.ProductOrd.NonTransitive.ProductOrd a)
instance forall k (f :: k -> *) (xs :: [k]). Data.Type.List.All GHC.Classes.Ord (Data.Type.List.Map f xs) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (Numeric.TypedList.TypedList f xs))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (a1, a2))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (a1, a2, a3))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (a1, a2, a3, a4))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (a1, a2, a3, a4, a5))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (a1, a2, a3, a4, a5, a6))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (a1, a2, a3, a4, a5, a6, a7))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7, GHC.Classes.Ord a8) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7, GHC.Classes.Ord a8, GHC.Classes.Ord a9) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9))


-- | Compare product types using partial <a>Ord</a> instances:
--   
--   <ul>
--   <li>if nor &lt;math&gt;, nor &lt;math&gt;, neither, &lt;math&gt;, then
--   <tt>compare a b == undefined</tt></li>
--   </ul>
--   
--   To remind yourself that <a>ProductOrd</a> is partial, you may import
--   it qualified, e.g.
--   
--   <pre>
--   import qualified Numeric.ProductOrd.Partial as Partial
--   </pre>
module Numeric.ProductOrd.Partial

-- | Redefine <a>Ord</a> instance for a type which is a cartesian product
--   -- as a partial <b><a>product order</a></b>.
--   
--   Since vanilla Haskell <a>Ord</a> class is always about total order,
--   <tt>ProductOrd</tt> instance is not particularly correct. However, it
--   turns out to be very useful for comparing vector or tuple-like types.
--   
--   The implementation of <a>ProductOrd</a> in this module workarounds
--   this by using a <b>partial <tt>compare</tt> function in an <a>Eq</a>
--   instance</b>: &lt;math&gt;
--   
--   Another inconsistency with the Haskell Report is the <a>min</a> and
--   <a>max</a> functions; these are simply element-wise minimum and
--   maximum here. Thus, these instances preserve important properties like
--   <tt>min a b &lt;= a &amp;&amp; min a b &lt;= b</tt>, but do not
--   preserve a property that <tt>min a b == a || min a b == b</tt>.
--   
--   All of this is really useful in geometry applications and for
--   calculating things like <a>Pareto dominance</a>, but should be used
--   with care. In particular, never use <tt>ProductOrd</tt> as a key to a
--   <tt>Set</tt> or a <tt>Map</tt>!
newtype ProductOrd a
ProductOrd :: a -> ProductOrd a
[getProductOrd] :: ProductOrd a -> a

-- | Treat <a>Incomparable</a> as error (partial function).
toOrdering :: PartialOrdering -> Ordering
instance Data.Bits.FiniteBits a => Data.Bits.FiniteBits (Numeric.ProductOrd.Partial.ProductOrd a)
instance Data.Bits.Bits a => Data.Bits.Bits (Numeric.ProductOrd.Partial.ProductOrd a)
instance Data.Traversable.Traversable Numeric.ProductOrd.Partial.ProductOrd
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Float.Floating a => GHC.Float.Floating (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Enum.Bounded a => GHC.Enum.Bounded (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Num.Num a => GHC.Num.Num (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Generics.Generic1 Numeric.ProductOrd.Partial.ProductOrd
instance GHC.Generics.Generic (Numeric.ProductOrd.Partial.ProductOrd a)
instance Data.Data.Data a => Data.Data.Data (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Read.Read a => GHC.Read.Read (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Show.Show a => GHC.Show.Show (Numeric.ProductOrd.Partial.ProductOrd a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Numeric.ProductOrd.Partial.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd a), GHC.Real.Integral a) => GHC.Real.Integral (Numeric.ProductOrd.Partial.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd a), GHC.Real.Real a) => GHC.Real.Real (Numeric.ProductOrd.Partial.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd a), GHC.Real.RealFrac a) => GHC.Real.RealFrac (Numeric.ProductOrd.Partial.ProductOrd a)
instance (GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd a), GHC.Float.RealFloat a) => GHC.Float.RealFloat (Numeric.ProductOrd.Partial.ProductOrd a)
instance Data.Foldable.Foldable Numeric.ProductOrd.Partial.ProductOrd
instance GHC.Base.Functor Numeric.ProductOrd.Partial.ProductOrd
instance GHC.Base.Applicative Numeric.ProductOrd.Partial.ProductOrd
instance GHC.Base.Monad Numeric.ProductOrd.Partial.ProductOrd
instance Control.Monad.Fix.MonadFix Numeric.ProductOrd.Partial.ProductOrd
instance Control.Monad.Zip.MonadZip Numeric.ProductOrd.Partial.ProductOrd
instance forall k (f :: k -> *) (xs :: [k]). Data.Type.List.All GHC.Classes.Ord (Data.Type.List.Map f xs) => GHC.Classes.Eq (Numeric.ProductOrd.Partial.ProductOrd (Numeric.TypedList.TypedList f xs))
instance forall k (f :: k -> *) (xs :: [k]). Data.Type.List.All GHC.Classes.Ord (Data.Type.List.Map f xs) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (Numeric.TypedList.TypedList f xs))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (a1, a2))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (a1, a2, a3))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (a1, a2, a3, a4))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (a1, a2, a3, a4, a5))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (a1, a2, a3, a4, a5, a6))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (a1, a2, a3, a4, a5, a6, a7))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7, GHC.Classes.Ord a8) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8))
instance (GHC.Classes.Ord a1, GHC.Classes.Ord a2, GHC.Classes.Ord a3, GHC.Classes.Ord a4, GHC.Classes.Ord a5, GHC.Classes.Ord a6, GHC.Classes.Ord a7, GHC.Classes.Ord a8, GHC.Classes.Ord a9) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (a1, a2, a3, a4, a5, a6, a7, a8, a9))


-- | The core <tt>easytensor</tt> types.
module Numeric.DataFrame.Type

-- | Data frame that has an unknown dimensionality at compile time.
--   Pattern-match against its constructor to get a Nat-indexed data frame
data SomeDataFrame (t :: l)
SomeDataFrame :: DataFrame t ns -> SomeDataFrame

-- | DataFrame with its type arguments swapped.
data DataFrame' (xs :: [k]) (t :: l)

-- | Keep data in a primitive data frame and maintain information about
--   Dimensions in the type system
data family DataFrame (t :: l) (xs :: [k])

-- | Empty MultiFrame
pattern Z :: forall (xs :: [Type]) (ns :: [Nat]). () => xs ~ '[] => DataFrame xs ns

-- | Constructing a <tt>MultiFrame</tt> using DataFrame columns
pattern (:*:) :: forall (xs :: [Type]) (ns :: [Nat]). () => forall (y :: Type) (ys :: [Type]). xs ~ (y : ys) => DataFrame y ns -> DataFrame ys ns -> DataFrame xs ns
infixr 6 :*:

-- | A scalar DataFrame is just a newtype wrapper on a value.
pattern S :: forall (t :: Type). t -> DataFrame t ('[] :: [Nat])
pattern DF2 :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions (2 : ds)) => (Dimensions ds, KnownBackend t ds) => DataFrame t ds -> DataFrame t ds -> DataFrame t (2 : ds)
pattern DF3 :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions (3 : ds)) => (Dimensions ds, KnownBackend t ds) => DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t (3 : ds)
pattern DF4 :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions (4 : ds)) => (Dimensions ds, KnownBackend t ds) => DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t (4 : ds)
pattern DF5 :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions (5 : ds)) => (Dimensions ds, KnownBackend t ds) => DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t (5 : ds)
pattern DF6 :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions (6 : ds)) => (Dimensions ds, KnownBackend t ds) => DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t (6 : ds)
pattern DF7 :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions (7 : ds)) => (Dimensions ds, KnownBackend t ds) => DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t (7 : ds)
pattern DF8 :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions (8 : ds)) => (Dimensions ds, KnownBackend t ds) => DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t (8 : ds)
pattern DF9 :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions (9 : ds)) => (Dimensions ds, KnownBackend t ds) => DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t ds -> DataFrame t (9 : ds)

-- | Convert any type to a scalar wrapper
scalar :: t -> DataFrame t ('[] :: [Nat])

-- | Convert a scalar back to an ordinary type
unScalar :: DataFrame t ('[] :: [Nat]) -> t

-- | Index one dimension deep into a <tt>DataFrame</tt>.
class IndexFrame t d ds

-- | Index one dimension deep into a <tt>DataFrame</tt>.
--   
--   Note, this function does not provide indexing safety at the type
--   level; it throws an <a>OutOfDimBounds</a> exception if an index is out
--   of bounds (unless <tt>unsafeindices</tt> package flag is enabled,
--   which is even more dangerous).
(!) :: IndexFrame t d ds => DataFrame t (d : ds) -> Word -> DataFrame t ds

-- | This type family describes two strategies for dealing with dimensions
--   when slicing a <tt>DataFrame</tt>.
--   
--   If the original space dimension (<tt>d</tt>) is fixed at compile time
--   (<tt>d :: Nat</tt> or <tt>d ~ N n</tt>), then we enforce the safety of
--   a slicing operation with types: the index space is bounded by the size
--   of the original space minus the subframe size.
--   
--   If the original space dimension (<tt>d</tt>) is not fixed (<tt>d ~ XN
--   m</tt>), then we give up. Just let the user do the slicing as easy as
--   possible, and throw an <a>OutOfDimBounds</a> exception at runtime if
--   the index plus the sliced size is greater than the original size of
--   the DataFrame.
type family SubFrameIndexCtx (d :: k) (idxN :: k) (subN :: k) :: Constraint

-- | Represent smart constructor functions <a>packDF</a> and
--   <a>unpackDF</a>.
type family PackDF (t :: Type) (ds :: [Nat]) (d :: Nat) (r :: Type) :: Type

-- | Takes <tt>d</tt> arguments of type <tt>DataFrame t ds</tt> and produce
--   a <tt>DataFrame t (d ': ds)</tt>.
--   
--   NB: always use <tt>TypeApplications</tt> extension with this function
--   to apply all type arguments! Otherwise, a very dumb type family
--   <tt>PackDF</tt> will not infer the types for you.
--   
--   The following example creates a <tt>Matrix Double 12 3</tt> filled
--   with twelve 3D vectors (using <tt>fromInteger</tt> of <tt>Vector
--   Double 3</tt>):
--   
--   <pre>
--   &gt;&gt;&gt; packDF @Double @12 @'[3] 1 2 3 4 5 6 7 8 9 10 11 12
--   </pre>
--   
--   <a>packDF</a> and <a>unpackDF</a> together serve as a generic
--   constructor for a DataFrame of an arbitrary (statically known) size.
packDF :: forall (t :: Type) (d :: Nat) (ds :: [Nat]). (PrimBytes t, Dimensions (d : ds)) => PackDF t ds d (DataFrame t (d : ds))

-- | Takes a function (e.g. a constructor) with <tt>d+1</tt> argument (df1,
--   df2, .. dfd, Dict) and a <tt>DataFrame t (d ': ds)</tt>. Feeds the
--   dataframe elements into that function. For example, you can pass a
--   tuple to this function, and get all dataframe elements (and some
--   dictionaries -- useful evidence to work with element frames)
--   
--   NB: always use <tt>TypeApplications</tt> extension with this function
--   to apply all type arguments! Otherwise, a very dumb type family
--   <tt>PackDF</tt> will not infer the types for you.
--   
--   The following example unpacks a 3D vector (created using
--   <tt>fromInteger</tt> of <tt>Vector Double 3</tt>) into a 4-tuple with
--   three scalars and one Dict:
--   
--   <pre>
--   &gt;&gt;&gt; unpackDF @Double @3 @'[] (,,,) 2
--   </pre>
--   
--   <a>packDF</a> and <a>unpackDF</a> together serve as a generic
--   constructor for a DataFrame of an arbitrary (statically known) size.
unpackDF :: forall (t :: Type) (d :: Nat) (ds :: [Nat]) (rep :: RuntimeRep) (r :: TYPE rep). (PrimBytes t, Dimensions (d : ds)) => PackDF t ds d (Dict (Dimensions ds, KnownBackend t ds) -> r) -> DataFrame t (d : ds) -> r

-- | Append one DataFrame to another, sum up the first dimension.
--   
--   If you want to deconstruct a DataFrame, use <a>index</a> or
--   <a>slice</a> instead.
appendDF :: forall (n :: Nat) (m :: Nat) (ds :: [Nat]) (t :: Type). (PrimBytes t, Dimensions ds, KnownDim n, KnownDim m) => DataFrame t (n :+ ds) -> DataFrame t (m :+ ds) -> DataFrame t ((n + m) :+ ds)

-- | Append a small DataFrame to a big DataFrame on the left.
--   
--   If you want to deconstruct a DataFrame, use <a>index</a> or
--   <a>slice</a> instead.
consDF :: forall (n :: Nat) (ds :: [Nat]) (t :: Type). (PrimBytes t, Dimensions ds, KnownDim n) => DataFrame t ds -> DataFrame t (n :+ ds) -> DataFrame t ((n + 1) :+ ds)

-- | Append a small DataFrame to a big DataFrame on the right.
--   
--   If you want to deconstruct a DataFrame, use <a>index</a> or
--   <a>slice</a> instead.
snocDF :: forall (n :: Nat) (ds :: [Nat]) (t :: Type). (PrimBytes t, Dimensions ds, KnownDim n) => DataFrame t (n :+ ds) -> DataFrame t ds -> DataFrame t ((n + 1) :+ ds)

-- | Construct a DataFrame from a flat list.
--   
--   The values are filled according to the DataFrame layout: row-by-row
--   and further from the last dimension (least significant) to the first
--   dimension (most significant).
--   
--   If the argument list is shorter than <tt>totalDim</tt>, then the rest
--   of the frame is padded with a default value (second argument).
--   
--   If the argument list is longer than <tt>totalDim</tt>, then unused
--   values are dropped. If you want, you can pass an infinite list as an
--   argument, i.e. the following is a valid use:
--   
--   <pre>
--   &gt;&gt;&gt; fromFlatList (dims :: Dims '[2,5]) 0 [6,8..]
--   </pre>
fromFlatList :: forall (t :: Type) (ds :: [Nat]). PrimArray t (DataFrame t ds) => Dims ds -> t -> [t] -> DataFrame t ds

-- | Construct a DataFrame from a list of smaller DataFrames.
--   
--   If the argument list is shorter than <tt>d</tt>, then the rest of the
--   frame is padded with a default value (first argument).
--   
--   If the argument list is longer than <tt>d</tt>, then unused values are
--   dropped. If you want, you can pass an infinite list as an argument.
fromListWithDefault :: forall (t :: Type) (d :: Nat) (ds :: [Nat]). (PrimBytes t, Dimensions (d : ds)) => DataFrame t ds -> [DataFrame t ds] -> DataFrame t (d : ds)

-- | Construct a dynamic DataFrame from a list of smaller DataFrames.
--   Pattern-match against the resulting <tt>XFrame</tt> to find out its
--   dimensionality.
--   
--   You must not provide an infinite list as an argument.
fromList :: forall (t :: Type) (ds :: [Nat]) (xds :: [XNat]). (PrimBytes t, Dimensions ds, xds ~ Map N ds, ds ~ UnMap N xds) => [DataFrame t ds] -> DataFrame t (XN 0 : xds)

-- | Try to convert between <tt>XNat</tt>-indexed DataFrames.
--   
--   This is useful for imposing restrictions on unknown DataFrames, e.g.
--   increasing the minimum number of elements.
constrainDF :: forall (ds :: [XNat]) (ys :: [XNat]) t. (BoundedDims ds, All KnownDimType ds) => DataFrame t ys -> Maybe (DataFrame t ds)

-- | Place elements of a vector on the main diagonal of a matrix; fill the
--   rest of the matrix with zeroes.
--   
--   Note, this function is naturally generalized onto higher dimensions
--   (which can be seen from the type signature).
--   
--   Note, the argument of this function does not fully determine its
--   result type. This may cause some obscure type errors. Specify type
--   parameters <tt>n</tt> and <tt>m</tt> explicitly or make sure the
--   result type is fixed.
asDiag :: forall (n :: Nat) (m :: Nat) (ds :: [Nat]) (t :: Type). (Dimensions ds, KnownDim n, KnownDim m, KnownBackend t (Min n m :+ ds), KnownBackend t (n :+ (m :+ ds)), PrimBytes t) => DataFrame t (Min n m :+ ds) -> DataFrame t (n :+ (m :+ ds))
class KnownBackend t ds BackendFamily t ds => KnownBackend t (ds :: [Nat])

-- | Implementation behind the DataFrame
type DFBackend (t :: Type) (ds :: [Nat]) = Backend I t ds (BackendFamily t ds)

-- | I use this kind-polymorphic constraint to generalize <tt>XFrame</tt>
--   and <tt>SomeDataFrame</tt> over <tt>SingleFrame</tt> and
--   <tt>MultiFrame</tt>.
type family KnownBackends (ts :: l) (ns :: [Nat]) :: Constraint

-- | Allow inferring <tt>KnownBackends</tt> if you know the dimensions and
--   the element types.
class InferKnownBackend t (ds :: [Nat])

-- | Infer <tt>KnownBackends</tt> if you know the dimensions and the
--   element types.
inferKnownBackend :: InferKnownBackend t ds => Dict (KnownBackends t ds)

-- | Evidence that the elements of the DataFrame are PrimBytes.
inferPrimElem :: forall (t :: Type) (d :: Nat) (ds :: [Nat]). KnownBackend t (d : ds) => DataFrame t (d : ds) -> Dict (PrimBytes t)

-- | Singleton type to store type-level dimension value.
--   
--   On the one hand, it can be used to let type-inference system know
--   relations between type-level naturals. On the other hand, this is just
--   a newtype wrapper on the <tt>Word</tt> type.
--   
--   Usually, the type parameter of <tt>Dim</tt> is either <tt>Nat</tt> or
--   <tt>XNat</tt>. If dimensionality of your data is known in advance, use
--   <tt>Nat</tt>; if you know the size of some dimensions, but do not know
--   the size of others, use <tt>XNat</tt>s to represent them.
data Dim (x :: k) :: forall k. () => k -> Type

-- | Match against this pattern to bring <a>KnownDim</a> instance into
--   scope.
pattern D :: forall k (d :: k). KnownDimType d => (KindOf d ~ Nat, KnownDim d) => Dim d

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D1 :: forall (n :: Nat). () => n ~ 1 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D25 :: forall (n :: Nat). () => n ~ 25 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D24 :: forall (n :: Nat). () => n ~ 24 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D23 :: forall (n :: Nat). () => n ~ 23 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D22 :: forall (n :: Nat). () => n ~ 22 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D21 :: forall (n :: Nat). () => n ~ 21 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D20 :: forall (n :: Nat). () => n ~ 20 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D19 :: forall (n :: Nat). () => n ~ 19 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D18 :: forall (n :: Nat). () => n ~ 18 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D17 :: forall (n :: Nat). () => n ~ 17 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D16 :: forall (n :: Nat). () => n ~ 16 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D15 :: forall (n :: Nat). () => n ~ 15 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D14 :: forall (n :: Nat). () => n ~ 14 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D13 :: forall (n :: Nat). () => n ~ 13 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D12 :: forall (n :: Nat). () => n ~ 12 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D11 :: forall (n :: Nat). () => n ~ 11 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D10 :: forall (n :: Nat). () => n ~ 10 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D9 :: forall (n :: Nat). () => n ~ 9 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D8 :: forall (n :: Nat). () => n ~ 8 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D7 :: forall (n :: Nat). () => n ~ 7 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D6 :: forall (n :: Nat). () => n ~ 6 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D5 :: forall (n :: Nat). () => n ~ 5 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D4 :: forall (n :: Nat). () => n ~ 4 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D3 :: forall (n :: Nat). () => n ~ 3 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D2 :: forall (n :: Nat). () => n ~ 2 => Dim n

-- | Match <tt>Dim n</tt> against a concrete <tt>Nat</tt>
pattern D0 :: forall (n :: Nat). () => n ~ 0 => Dim n

-- | <a>XNat</a> that is unknown at compile time. Same as <a>SomeNat</a>,
--   but for a dimension: Hide dimension size inside, but allow specifying
--   its minimum possible value.
pattern Dx :: forall (d :: XNat). KnownDimType d => forall (m :: Nat) (n :: Nat). (KindOf d ~ XNat, d ~ XN m, m <= n) => Dim n -> Dim d

-- | Statically known <a>XNat</a>
pattern Dn :: forall (d :: XNat). KnownDimType d => forall (n :: Nat). (KindOf d ~ XNat, d ~ N n) => Dim n -> Dim d

-- | This type is used to index a single dimension.
--   
--   <ul>
--   <li><tt>(k ~ Nat) =&gt;</tt> the range of indices is from <tt>0</tt>
--   to <tt>d-1</tt>.</li>
--   <li><tt>(d ~ N n) =&gt;</tt> the range of indices is from <tt>0</tt>
--   to <tt>n-1</tt>.</li>
--   <li><tt>(d ~ XN m) =&gt;</tt> the range of indices is from <tt>0</tt>
--   to <tt>maxBound :: Word</tt>.</li>
--   </ul>
--   
--   That is, using <tt>Idx (n :: Nat)</tt> or <tt>Idx (N n)</tt> is
--   guaranteed to be safe by the type system. But an index of type <tt>Idx
--   (XN m)</tt> can have any value, and using it may yield an
--   <a>OutOfDimBounds</a> exception -- just the same as a generic
--   <tt>index</tt> function that takes a plain <tt>Int</tt> or
--   <tt>Word</tt> as an argument. Thus, if you have data indexed by
--   <tt>(XN m)</tt>, I would suggest to use <tt>lookup</tt>-like functions
--   that return <tt>Maybe</tt>. You're warned.
data Idx (d :: k) :: forall k. () => k -> Type

-- | (Kind) This is the kind of type-level natural numbers.
data Nat

-- | Either known or unknown at compile-time natural number
data XNat
XN :: Nat -> XNat
N :: Nat -> XNat

-- | Known natural number
type N = N

-- | Unknown natural number, known to be not smaller than the given Nat
type XN = XN

-- | Type-level dimensionality.
type Dims = TypedList (Dim :: k -> Type)

-- | Type-level dimensional indexing with arbitrary Word values inside.
--   Most of the operations on it require <a>Dimensions</a> or
--   <a>BoundedDims</a> constraint, because the <tt>Idxs</tt> itself does
--   not store info about dimension bounds.
type Idxs = TypedList (Idx :: k -> Type)

-- | Type-indexed list
data TypedList (f :: k -> Type) (xs :: [k]) :: forall k. () => k -> Type -> [k] -> Type

-- | Zero-length type list; synonym to <a>U</a>.
pattern Empty :: forall k (f :: k -> Type) (xs :: [k]). () => xs ~ ([] :: [k]) => TypedList f xs

-- | Reverse a typed list
pattern Reverse :: forall k (f :: k -> Type) (xs :: [k]). () => forall (sx :: [k]). ReverseList xs sx => TypedList f sx -> TypedList f xs

-- | Constructing a type-indexed list from the other end
pattern Snoc :: forall k (f :: k -> Type) (xs :: [k]). () => forall (sy :: [k]) (y :: k). SnocList sy y xs => TypedList f sy -> f y -> TypedList f xs

-- | Constructing a type-indexed list in the canonical way
pattern Cons :: forall k (f :: k -> Type) (xs :: [k]). () => forall (y :: k) (ys :: [k]). xs ~ (y : ys) => f y -> TypedList f ys -> TypedList f xs

-- | Pattern matching against this causes <a>RepresentableList</a> instance
--   come into scope. Also it allows constructing a term-level list out of
--   a constraint.
pattern TypeList :: forall k (xs :: [k]). () => RepresentableList xs => TypeList xs

-- | Constructing a type-indexed list
pattern (:*) :: forall k (f :: k -> Type) (xs :: [k]). () => forall (y :: k) (ys :: [k]). xs ~ (y : ys) => f y -> TypedList f ys -> TypedList f xs

-- | Zero-length type list
pattern U :: forall k (f :: k -> Type) (xs :: [k]). () => xs ~ ([] :: [k]) => TypedList f xs

-- | <tt>O(1)</tt> Pattern-matching against this constructor brings a
--   <a>Dimensions</a> instance into the scope. Thus, you can do arbitrary
--   operations on your dims and use this pattern at any time to
--   reconstruct the class instance at runtime.
pattern Dims :: forall k (ds :: [k]). KnownDimKind (KindOfEl ds) => (KindOfEl ds ~ Nat, Dimensions ds) => Dims ds

-- | <tt>O(Length ds)</tt> A heavy weapon against all sorts of type errors
pattern KnownDims :: forall (ds :: [Nat]). () => (All (KnownDim :: Nat -> Constraint) ds, All (BoundedDim :: Nat -> Constraint) ds, RepresentableList ds, Dimensions ds) => Dims ds

-- | <tt>O(n)</tt> Pattern-matching against this constructor reveals
--   Nat-kinded list of dims, pretending the dimensionality is known at
--   compile time within the scope of the pattern match. This is the main
--   recommended way to get <a>Dims</a> at runtime; for example, reading a
--   list of dimensions from a file.
pattern XDims :: forall (ds :: [XNat]). KnownDimKind (KindOfEl ds) => forall (ns :: [Nat]). (KindOfEl ds ~ XNat, FixedDims ds ns) => Dims ns -> Dims ds

-- | Transform between <tt>Nat</tt>-indexed and <tt>XNat</tt>-indexed
--   <tt>Idxs</tt>.
--   
--   Note, this pattern is not a <tt>COMPLETE</tt> match, because
--   converting from <tt>XNat</tt> to <tt>Nat</tt> indexed <tt>Idxs</tt>
--   may fail (see <a>unliftIdxs</a>).
pattern XIdxs :: forall (ds :: [XNat]) (ns :: [Nat]). (FixedDims ds ns, Dimensions ns) => () => Idxs ns -> Idxs ds
infixr 5 :*

-- | Defines how to read and write your data to and from Haskell unboxed
--   byte arrays and plain pointers.
--   
--   Similarly to <a>Storable</a>, this class provides functions to get the
--   size and alignment of a data via phantom arguments. Thus, the size and
--   alignment of the data must not depend on the data content (they depend
--   only on the type of the data). In particular, this means that
--   dynamically sized structures like Haskell lists or maps are not
--   allowed.
--   
--   This module provides default implementations for all methods of this
--   class via <a>Generic</a>. Hence, to make your data an instance of
--   <tt>PrimBytes</tt>, it is sufficient to write the instance head:
--   
--   <pre>
--   data MyData a b = ...
--     deriving Generic
--   
--   instance (PrimBytes a, PrimBytes b) =&gt; PrimBytes (MyData a b)
--   </pre>
--   
--   .. or use the <tt>DeriveAnyClass</tt> extension to make it even
--   shorter:
--   
--   <pre>
--   data MyData a b = ...
--     deriving (Generic, PrimBytes)
--   </pre>
--   
--   The derived instance tries to pack the data as dense as possible, but
--   sometimes it is better to write the instance by hand. If a derived
--   type has more than one constructor, the derived instance puts a
--   <tt>Word32</tt> tag at the beginning of the byte representation. All
--   fields of a constructor are packed in a C-like fashion next to each
--   other, while respecting their alignments.
class PrimTagged a => PrimBytes a

-- | A wrapper on <a>byteSize</a>
bSizeOf :: (PrimBytes a, Num b) => a -> b

-- | A wrapper on <a>byteAlign</a>
bAlignOf :: (PrimBytes a, Num b) => a -> b

-- | A wrapper on <a>byteFieldOffset</a>.
bFieldOffsetOf :: forall (name :: Symbol) (a :: Type) (b :: Type). (PrimBytes a, Elem name (PrimFields a), KnownSymbol name, Num b) => a -> b
class PrimBytes t => PrimArray t a | a -> t

-- | Index array by an integer offset (starting from 0).
ixOff :: PrimArray t a => Int -> a -> t
instance forall k l (t :: l) (xs :: [k]). (Data.Data.Data (Numeric.DataFrame.Type.DataFrame t xs), Data.Typeable.Internal.Typeable t, Data.Typeable.Internal.Typeable xs, Data.Typeable.Internal.Typeable k, Data.Typeable.Internal.Typeable l) => Data.Data.Data (Numeric.DataFrame.Type.DataFrame' xs t)
instance GHC.Classes.Eq (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Classes.Eq (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Classes.Ord (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Classes.Ord (Numeric.DataFrame.Type.DataFrame t ds)
instance Numeric.ProductOrd.ProductOrder (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => Numeric.ProductOrd.ProductOrder (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Enum.Bounded (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Enum.Bounded (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Enum.Enum (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Enum.Enum (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Real.Integral (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Real.Integral (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Num.Num (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Num.Num (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Real.Fractional (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Real.Fractional (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Float.Floating (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Float.Floating (Numeric.DataFrame.Type.DataFrame t ds)
instance Numeric.Basics.Epsilon (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => Numeric.Basics.Epsilon (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Real.Real (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Real.Real (Numeric.DataFrame.Type.DataFrame t ds)
instance Numeric.Basics.RealExtras (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => Numeric.Basics.RealExtras (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Real.RealFrac (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Real.RealFrac (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Float.RealFloat (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => GHC.Float.RealFloat (Numeric.DataFrame.Type.DataFrame t ds)
instance Numeric.Basics.RealFloatExtras (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => Numeric.Basics.RealFloatExtras (Numeric.DataFrame.Type.DataFrame t ds)
instance Numeric.PrimBytes.PrimBytes (Numeric.DataFrame.Internal.BackendI.DFBackend t ds) => Numeric.PrimBytes.PrimBytes (Numeric.DataFrame.Type.DataFrame t ds)
instance (Numeric.DataFrame.Internal.PrimArray.PrimArray t (Numeric.DataFrame.Internal.BackendI.DFBackend t ds), Numeric.PrimBytes.PrimBytes t) => Numeric.DataFrame.Internal.PrimArray.PrimArray t (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Generics.Generic (Numeric.DataFrame.Type.DataFrame ts ds)
instance (Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.Dimensions ds) => GHC.Generics.Generic (Numeric.DataFrame.Type.DataFrame t ds)
instance (Data.Data.Data t, Numeric.PrimBytes.PrimBytes t, Data.Typeable.Internal.Typeable ds) => Data.Data.Data (Numeric.DataFrame.Type.DataFrame t ds)
instance (Numeric.DataFrame.Internal.PrimArray.PrimArray t (Numeric.DataFrame.Type.DataFrame t '[d]), Numeric.Dimensions.Dim.KnownDim d) => Numeric.DataFrame.Type.IndexFrame t d '[]
instance (Numeric.DataFrame.Internal.PrimArray.PrimArray t (Numeric.DataFrame.Type.DataFrame t (d : ds)), Numeric.Dimensions.Dim.KnownDim d, Numeric.DataFrame.Internal.Backend.KnownBackend t ds) => Numeric.DataFrame.Type.IndexFrame t d ds
instance Numeric.DataFrame.Type.IndexFrame '[] d ds
instance (Numeric.DataFrame.Type.IndexFrame t d ds, Numeric.DataFrame.Type.IndexFrame ts d ds) => Numeric.DataFrame.Type.IndexFrame (t : ts) d ds
instance Numeric.PrimBytes.PrimBytes t => Numeric.DataFrame.Type.IndexFrame t xd xds
instance (Numeric.TypedList.RepresentableList ts, Data.Type.List.All Numeric.PrimBytes.PrimBytes ts) => Numeric.DataFrame.Type.IndexFrame ts xd xds
instance Numeric.DataFrame.Type.AllFrames GHC.Classes.Eq ts ds => GHC.Classes.Eq (Numeric.DataFrame.Type.DataFrame ts ds)
instance (Numeric.DataFrame.Type.AllFrames Data.Data.Data ts ds, Data.Typeable.Internal.Typeable ts, Data.Typeable.Internal.Typeable ds) => Data.Data.Data (Numeric.DataFrame.Type.DataFrame ts ds)
instance (Numeric.DataFrame.Type.AllFrames GHC.Classes.Eq ts ds, Numeric.DataFrame.Type.AllFrames GHC.Classes.Ord ts ds) => GHC.Classes.Ord (Numeric.DataFrame.Type.DataFrame ts ds)
instance (Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.Dimensions ds) => Numeric.DataFrame.Type.InferKnownBackend t ds
instance (Numeric.TypedList.RepresentableList ts, Data.Type.List.All Numeric.PrimBytes.PrimBytes ts, Numeric.Dimensions.Dim.Dimensions ds) => Numeric.DataFrame.Type.InferKnownBackend ts ds
instance GHC.Classes.Eq t => GHC.Classes.Eq (Numeric.DataFrame.Type.SomeDataFrame t)
instance Data.Type.List.All GHC.Classes.Eq ts => GHC.Classes.Eq (Numeric.DataFrame.Type.SomeDataFrame ts)
instance (GHC.Show.Show t, Numeric.PrimBytes.PrimBytes t) => GHC.Show.Show (Numeric.DataFrame.Type.SomeDataFrame t)
instance (Data.Type.List.All GHC.Show.Show ts, Data.Type.List.All Numeric.PrimBytes.PrimBytes ts) => GHC.Show.Show (Numeric.DataFrame.Type.SomeDataFrame ts)
instance (GHC.Read.Read t, Numeric.PrimBytes.PrimBytes t) => GHC.Read.Read (Numeric.DataFrame.Type.SomeDataFrame t)
instance (Data.Type.List.All GHC.Read.Read ts, Data.Type.List.All Numeric.PrimBytes.PrimBytes ts, Numeric.TypedList.RepresentableList ts) => GHC.Read.Read (Numeric.DataFrame.Type.SomeDataFrame ts)
instance forall l (xns :: [Numeric.Dimensions.Dim.XNat]) (ts :: l). (Numeric.Dimensions.Dim.Dimensions xns, Numeric.DataFrame.Type.KnownBackends ts (Numeric.Dimensions.Dim.DimsBound xns), GHC.Num.Num (Numeric.DataFrame.Type.DataFrame ts (Numeric.Dimensions.Dim.DimsBound xns))) => GHC.Num.Num (Numeric.DataFrame.Type.DataFrame ts xns)
instance forall l (xns :: [Numeric.Dimensions.Dim.XNat]) (ts :: l). (Numeric.Dimensions.Dim.Dimensions xns, Numeric.DataFrame.Type.KnownBackends ts (Numeric.Dimensions.Dim.DimsBound xns), GHC.Real.Fractional (Numeric.DataFrame.Type.DataFrame ts (Numeric.Dimensions.Dim.DimsBound xns))) => GHC.Real.Fractional (Numeric.DataFrame.Type.DataFrame ts xns)
instance forall l (xns :: [Numeric.Dimensions.Dim.XNat]) (ts :: l). (Numeric.Dimensions.Dim.Dimensions xns, Numeric.DataFrame.Type.KnownBackends ts (Numeric.Dimensions.Dim.DimsBound xns), GHC.Float.Floating (Numeric.DataFrame.Type.DataFrame ts (Numeric.Dimensions.Dim.DimsBound xns))) => GHC.Float.Floating (Numeric.DataFrame.Type.DataFrame ts xns)
instance forall l (xns :: [Numeric.Dimensions.Dim.XNat]) (ts :: l). (Numeric.Dimensions.Dim.Dimensions xns, Numeric.DataFrame.Type.KnownBackends ts (Numeric.Dimensions.Dim.DimsBound xns), GHC.Enum.Bounded (Numeric.DataFrame.Type.DataFrame ts (Numeric.Dimensions.Dim.DimsBound xns))) => GHC.Enum.Bounded (Numeric.DataFrame.Type.DataFrame ts xns)
instance forall l (xns :: [Numeric.Dimensions.Dim.XNat]) (ts :: l). (Numeric.Dimensions.Dim.Dimensions xns, Numeric.DataFrame.Type.KnownBackends ts (Numeric.Dimensions.Dim.DimsBound xns), Numeric.PrimBytes.PrimBytes (Numeric.DataFrame.Type.DataFrame ts (Numeric.Dimensions.Dim.DimsBound xns))) => Numeric.PrimBytes.PrimBytes (Numeric.DataFrame.Type.DataFrame ts xns)
instance forall l (ts :: l). (GHC.Enum.Enum (Numeric.DataFrame.Type.DataFrame ts '[]), Numeric.DataFrame.Type.KnownBackends ts '[]) => GHC.Enum.Enum (Numeric.DataFrame.Type.DataFrame ts '[])
instance forall l (ts :: l). (Numeric.Basics.Epsilon (Numeric.DataFrame.Type.DataFrame ts '[]), Numeric.DataFrame.Type.KnownBackends ts '[], GHC.Classes.Eq (Numeric.DataFrame.Type.DataFrame ts '[])) => Numeric.Basics.Epsilon (Numeric.DataFrame.Type.DataFrame ts '[])
instance forall l (ts :: l). (GHC.Real.Real (Numeric.DataFrame.Type.DataFrame ts '[]), Numeric.DataFrame.Type.KnownBackends ts '[], GHC.Classes.Eq (Numeric.DataFrame.Type.DataFrame ts '[])) => GHC.Real.Real (Numeric.DataFrame.Type.DataFrame ts '[])
instance forall l (ts :: l). (GHC.Real.Integral (Numeric.DataFrame.Type.DataFrame ts '[]), Numeric.DataFrame.Type.KnownBackends ts '[], GHC.Classes.Eq (Numeric.DataFrame.Type.DataFrame ts '[])) => GHC.Real.Integral (Numeric.DataFrame.Type.DataFrame ts '[])
instance GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (Numeric.DataFrame.Internal.BackendI.DFBackend t ds)) => GHC.Classes.Ord (Numeric.ProductOrd.NonTransitive.ProductOrd (Numeric.DataFrame.Type.DataFrame t ds))
instance (GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (Numeric.DataFrame.Internal.BackendI.DFBackend t ds)), GHC.Classes.Eq (Numeric.DataFrame.Internal.BackendI.DFBackend t ds)) => GHC.Classes.Ord (Numeric.ProductOrd.Partial.ProductOrd (Numeric.DataFrame.Type.DataFrame t ds))
instance forall k l (t :: l) (ds :: [k]). Numeric.PrimBytes.PrimBytes (Numeric.DataFrame.Type.DataFrame t ds) => Foreign.Storable.Storable (Numeric.DataFrame.Type.DataFrame t ds)
instance GHC.Classes.Eq t => GHC.Classes.Eq (Numeric.DataFrame.Type.DataFrame t ds)
instance Data.Type.List.All GHC.Classes.Eq ts => GHC.Classes.Eq (Numeric.DataFrame.Type.DataFrame ts ds)
instance (GHC.Show.Show t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.Dimensions ds) => GHC.Show.Show (Numeric.DataFrame.Type.DataFrame t ds)
instance (Data.Type.List.All GHC.Show.Show ts, Data.Type.List.All Numeric.PrimBytes.PrimBytes ts, Numeric.Dimensions.Dim.Dimensions ds) => GHC.Show.Show (Numeric.DataFrame.Type.DataFrame ts ds)
instance (GHC.Show.Show t, Numeric.PrimBytes.PrimBytes t) => GHC.Show.Show (Numeric.DataFrame.Type.DataFrame t xns)
instance (Data.Type.List.All GHC.Show.Show ts, Data.Type.List.All Numeric.PrimBytes.PrimBytes ts) => GHC.Show.Show (Numeric.DataFrame.Type.DataFrame ts xns)
instance (GHC.Read.Read t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.Dimensions ds) => GHC.Read.Read (Numeric.DataFrame.Type.DataFrame t ds)
instance (Data.Type.List.All GHC.Read.Read ts, Data.Type.List.All Numeric.PrimBytes.PrimBytes ts, Numeric.TypedList.RepresentableList ts, Numeric.Dimensions.Dim.Dimensions ds) => GHC.Read.Read (Numeric.DataFrame.Type.DataFrame ts ds)
instance (GHC.Read.Read t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.BoundedDims ds, Data.Type.List.All Numeric.Dimensions.Dim.KnownDimType ds) => GHC.Read.Read (Numeric.DataFrame.Type.DataFrame t ds)
instance (Data.Type.List.All GHC.Read.Read ts, Data.Type.List.All Numeric.PrimBytes.PrimBytes ts, Numeric.TypedList.RepresentableList ts, Numeric.Dimensions.Dim.BoundedDims ds, Data.Type.List.All Numeric.Dimensions.Dim.KnownDimType ds) => GHC.Read.Read (Numeric.DataFrame.Type.DataFrame ts ds)
instance forall l (xns :: [Numeric.Dimensions.Dim.XNat]) (ts :: l). (xns Data.Type.Equality.~ Data.Type.List.Map 'Numeric.Dimensions.Dim.N (Numeric.Dimensions.Dim.DimsBound xns), GHC.Classes.Eq (Numeric.DataFrame.Type.DataFrame ts xns), GHC.Classes.Ord (Numeric.DataFrame.Type.DataFrame ts (Numeric.Dimensions.Dim.DimsBound xns))) => GHC.Classes.Ord (Numeric.DataFrame.Type.DataFrame ts xns)
instance forall l (xns :: [Numeric.Dimensions.Dim.XNat]) (ts :: l). (xns Data.Type.Equality.~ Data.Type.List.Map 'Numeric.Dimensions.Dim.N (Numeric.Dimensions.Dim.DimsBound xns), Numeric.ProductOrd.ProductOrder (Numeric.DataFrame.Type.DataFrame ts (Numeric.Dimensions.Dim.DimsBound xns))) => Numeric.ProductOrd.ProductOrder (Numeric.DataFrame.Type.DataFrame ts xns)
instance (Numeric.Dimensions.Dim.Dimensions xns, Numeric.DataFrame.Internal.Backend.KnownBackend t (Numeric.Dimensions.Dim.DimsBound xns), Numeric.DataFrame.Internal.PrimArray.PrimArray t (Numeric.DataFrame.Type.DataFrame t (Numeric.Dimensions.Dim.DimsBound xns)), Numeric.PrimBytes.PrimBytes t) => Numeric.DataFrame.Internal.PrimArray.PrimArray t (Numeric.DataFrame.Type.DataFrame t xns)
instance (Numeric.Basics.RealExtras (Numeric.DataFrame.Type.DataFrame t '[]), Numeric.DataFrame.Internal.Backend.KnownBackend t '[], GHC.Classes.Eq t) => Numeric.Basics.RealExtras (Numeric.DataFrame.Type.DataFrame t '[])
instance (GHC.Real.RealFrac (Numeric.DataFrame.Type.DataFrame t '[]), Numeric.DataFrame.Internal.Backend.KnownBackend t '[], GHC.Classes.Eq t) => GHC.Real.RealFrac (Numeric.DataFrame.Type.DataFrame t '[])
instance (GHC.Float.RealFloat (Numeric.DataFrame.Type.DataFrame t '[]), Numeric.DataFrame.Internal.Backend.KnownBackend t '[], GHC.Classes.Eq t) => GHC.Float.RealFloat (Numeric.DataFrame.Type.DataFrame t '[])
instance (Numeric.Basics.RealFloatExtras (Numeric.DataFrame.Type.DataFrame t '[]), Numeric.DataFrame.Internal.Backend.KnownBackend t '[], GHC.Classes.Eq t) => Numeric.Basics.RealFloatExtras (Numeric.DataFrame.Type.DataFrame t '[])


-- | Interface to perform primitive stateful operations on mutable frames.
module Numeric.DataFrame.Internal.Mutable

-- | Mutable DataFrame type. Keeps element offset, number of elements, and
--   a mutable byte storage
data MDataFrame s t (ns :: [k])

-- | Allow coercing between <tt>XNat</tt>-indexed and <tt>Nat</tt>-indexed
--   Mutable DataFrames.
castDataFrame# :: forall (t :: Type) (xns :: [XNat]) (ns :: [Nat]) s. FixedDims xns ns => MDataFrame s t ns -> MDataFrame s t xns

-- | Create a new mutable DataFrame.
newDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. (PrimBytes t, Dimensions ns) => State# s -> (# State# s, MDataFrame s t ns #)

-- | Create a new mutable DataFrame.
newPinnedDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. (PrimBytes t, Dimensions ns) => State# s -> (# State# s, MDataFrame s t ns #)

-- | Create a new mutable DataFrame of the same size.
oneMoreDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. MDataFrame s t ns -> State# s -> (# State# s, MDataFrame s t ns #)

-- | View a part of a DataFrame.
--   
--   This function does not perform a copy. All changes to a new DataFrame
--   will be reflected in the original DataFrame as well.
--   
--   If any of the dims in <tt>as</tt> or <tt>b</tt> is unknown (<tt>a ~ XN
--   m</tt>), then this function is unsafe and can throw an
--   <a>OutOfDimBounds</a> exception. Otherwise, its safety is guaranteed
--   by the type system.
subDataFrameView# :: forall (t :: Type) (k :: Type) (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k]) (asbs :: [k]) s. (SubFrameIndexCtx b bi bd, KnownDim bd, ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> MDataFrame s t asbs -> MDataFrame s t (bd :+ bs)

-- | View a part of a DataFrame.
--   
--   This function does not perform a copy. All changes to a new DataFrame
--   will be reflected in the original DataFrame as well.
--   
--   This is a simpler version of <tt>subDataFrameView</tt> that allows to
--   view over one index at a time.
--   
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
subDataFrameView'# :: forall (t :: Type) (k :: Type) (as :: [k]) (bs :: [k]) (asbs :: [k]) s. ConcatList as bs asbs => Idxs as -> MDataFrame s t asbs -> MDataFrame s t bs

-- | Copy one DataFrame into another mutable DataFrame at specified
--   position.
--   
--   In contrast to <tt>copyDataFrame'</tt>, this function allows to copy
--   over a range of contiguous indices over a single dimension. For
--   example, you can write a 3x4 matrix into a 7x4 matrix, starting at
--   indices 0..3.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing. If (<tt>b ~ XN m</tt>) and (<tt>Idx bi + Dim bd
--   &gt; Dim b</tt>), this function copies only as many elements as fits
--   into the dataframe along this dimension (possibly none).
copyDataFrame# :: forall (t :: Type) (k :: Type) (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k]) (asbs :: [k]) s. (SubFrameIndexCtx b bi bd, KnownDim bd, ExactDims bs, PrimArray t (DataFrame t (bd :+ bs)), ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> DataFrame t (bd :+ bs) -> MDataFrame s t asbs -> State# s -> (# State# s, () #)

-- | Copy one mutable DataFrame into another mutable DataFrame at specified
--   position.
--   
--   In contrast to <tt>copyMutableDataFrame'</tt>, this function allows to
--   copy over a range of contiguous indices over a single dimension. For
--   example, you can write a 3x4 matrix into a 7x4 matrix, starting at
--   indices 0..3.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing. If (<tt>b ~ XN m</tt>) and (<tt>Idx bi + Dim bd
--   &gt; Dim b</tt>), this function copies only as many elements as fits
--   into the dataframe along this dimension (possibly none).
copyMDataFrame# :: forall (t :: Type) (k :: Type) (b :: k) (bi :: k) (bd :: k) (as :: [k]) (bs :: [k]) (asbs :: [k]) s. (SubFrameIndexCtx b bi bd, ExactDims bs, PrimBytes t, ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> MDataFrame s t (bd :+ bs) -> MDataFrame s t asbs -> State# s -> (# State# s, () #)

-- | Copy one DataFrame into another mutable DataFrame at specified
--   position.
--   
--   This is a simpler version of <tt>copyDataFrame</tt> that allows to
--   copy over one index at a time.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
copyDataFrame'# :: forall (t :: Type) (k :: Type) (as :: [k]) (bs :: [k]) (asbs :: [k]) s. (ExactDims bs, PrimArray t (DataFrame t bs), ConcatList as bs asbs) => Idxs as -> DataFrame t bs -> MDataFrame s t asbs -> State# s -> (# State# s, () #)

-- | Copy one mutable DataFrame into another mutable DataFrame at specified
--   position.
--   
--   This is a simpler version of <tt>copyMutableDataFrame</tt> that allows
--   to copy over one index at a time.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
copyMDataFrame'# :: forall (t :: Type) (k :: Type) (as :: [k]) (bs :: [k]) (asbs :: [k]) s. (ExactDims bs, PrimBytes t, ConcatList as bs asbs) => Idxs as -> MDataFrame s t bs -> MDataFrame s t asbs -> State# s -> (# State# s, () #)

-- | Copy one DataFrame into another mutable DataFrame by offset in
--   primitive elements.
--   
--   This is a low-level copy function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds.
copyDataFrameOff# :: forall (t :: Type) (k :: Type) (as :: [k]) (bs :: [k]) (asbs :: [k]) s. (Dimensions bs, PrimArray t (DataFrame t bs), ConcatList as bs asbs) => Int -> DataFrame t bs -> MDataFrame s t asbs -> State# s -> (# State# s, () #)

-- | Copy one mutable DataFrame into another mutable DataFrame by offset in
--   primitive elements.
--   
--   This is a low-level copy function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds.
copyMDataFrameOff# :: forall (t :: Type) (k :: Type) (as :: [k]) (bs :: [k]) (asbs :: [k]) s. (ExactDims bs, PrimBytes t, ConcatList as bs asbs) => Int -> MDataFrame s t bs -> MDataFrame s t asbs -> State# s -> (# State# s, () #)

-- | Copy content of a mutable DataFrame into a new immutable DataFrame.
freezeDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. PrimArray t (DataFrame t ns) => MDataFrame s t ns -> State# s -> (# State# s, DataFrame t ns #)

-- | Make a mutable DataFrame immutable, without copying.
unsafeFreezeDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. PrimArray t (DataFrame t ns) => MDataFrame s t ns -> State# s -> (# State# s, DataFrame t ns #)

-- | Create a new mutable DataFrame and copy content of immutable one in
--   there.
thawDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> State# s -> (# State# s, MDataFrame s t ns #)

-- | Create a new mutable DataFrame and copy content of immutable one in
--   there. The result array is pinned and aligned.
thawPinDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> State# s -> (# State# s, MDataFrame s t ns #)

-- | UnsafeCoerces an underlying byte array.
unsafeThawDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> State# s -> (# State# s, MDataFrame s t ns #)

-- | Given two continuations <tt>f</tt> and <tt>g</tt>. If the input
--   DataFrame is a single broadcast value, use it in <tt>f</tt>.
--   Otherwise, create a new mutable DataFrame and copy content of
--   immutable one in there; then use it in <tt>g</tt>.
--   
--   This function is useful when <tt>thawDataFrame</tt> cannot be used due
--   to <tt>Dimensions ns</tt> constraint being not available.
withThawDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) (r :: Type) s. PrimArray t (DataFrame t ns) => (t -> State# s -> (# State# s, r #)) -> (MDataFrame s t ns -> State# s -> (# State# s, r #)) -> DataFrame t ns -> State# s -> (# State# s, r #)

-- | Write a single element at the specified index.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
writeDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. PrimBytes (DataFrame t ('[] :: [k])) => MDataFrame s t ns -> Idxs ns -> DataFrame t ('[] :: [k]) -> State# s -> (# State# s, () #)

-- | Write a single element at the specified element offset.
--   
--   This is a low-level write function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds.
writeDataFrameOff# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. PrimBytes (DataFrame t ('[] :: [k])) => MDataFrame s t ns -> Int -> DataFrame t ('[] :: [k]) -> State# s -> (# State# s, () #)

-- | Read a single element at the specified index.
--   
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
readDataFrame# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. PrimBytes (DataFrame t ('[] :: [k])) => MDataFrame s t ns -> Idxs ns -> State# s -> (# State# s, DataFrame t ('[] :: [k]) #)

-- | Read a single element at the specified element offset.
--   
--   This is a low-level read function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you read beyond the DataFrame
--   bounds.
readDataFrameOff# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. PrimBytes (DataFrame t ('[] :: [k])) => MDataFrame s t ns -> Int -> State# s -> (# State# s, DataFrame t ('[] :: [k]) #)

-- | Allow arbitrary operations on a pointer to the beginning of the data.
--   Only possible with <tt>RealWord</tt> state (thus, in <tt>IO</tt>) due
--   to semantics of <tt>touch#</tt> operation that keeps the data from
--   being garbage collected.
withDataFramePtr# :: forall (t :: Type) (k :: Type) (ns :: [k]) (r :: Type). PrimBytes t => MDataFrame RealWorld t ns -> (Addr# -> State# RealWorld -> (# State# RealWorld, r #)) -> State# RealWorld -> (# State# RealWorld, r #)

-- | Check if the byte array wrapped by this DataFrame is pinned, which
--   means cannot be relocated by GC.
isDataFramePinned# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. MDataFrame s t ns -> Bool

-- | Get cumulative dimensions <tt>ns</tt> of a <tt>MDataFrame s t ns</tt>
getDataFrameSteps# :: forall (t :: Type) (k :: Type) (ns :: [k]) s. MDataFrame s t ns -> CumulDims


-- | Mutable DataFrames living in ST.
module Numeric.DataFrame.ST

-- | Mutable DataFrame that lives in ST. Internal representation is always
--   a MutableByteArray.
data STDataFrame s (t :: Type) (ns :: [k])

-- | Data frame with some dimensions missing at compile time. Pattern-match
--   against its constructor to get a Nat-indexed mutable data frame.
pattern XSTFrame :: forall s (t :: Type) (xns :: [XNat]). () => forall (ns :: [Nat]). (FixedDims xns ns, Dimensions ns) => STDataFrame s t ns -> STDataFrame s t xns

-- | Mutable DataFrame of unknown dimensionality
data SomeSTDataFrame s (t :: Type)
SomeSTDataFrame :: STDataFrame s t ns -> SomeSTDataFrame s

-- | Allow coercing between <tt>XNat</tt>-indexed and <tt>Nat</tt>-indexed
--   Mutable DataFrames.
castDataFrame :: forall (t :: Type) (xns :: [XNat]) (ns :: [Nat]) s. FixedDims xns ns => STDataFrame s t ns -> STDataFrame s t xns

-- | Create a new mutable DataFrame.
newDataFrame :: forall (t :: Type) ns s. (PrimBytes t, Dimensions ns) => ST s (STDataFrame s t ns)

-- | Create a new mutable DataFrame.
newPinnedDataFrame :: forall (t :: Type) ns s. (PrimBytes t, Dimensions ns) => ST s (STDataFrame s t ns)

-- | Create a new mutable DataFrame of the same size.
oneMoreDataFrame :: forall (t :: Type) ns s. STDataFrame s t ns -> ST s (STDataFrame s t ns)

-- | View a part of a DataFrame.
--   
--   This function does not perform a copy. All changes to a new DataFrame
--   will be reflected in the original DataFrame as well.
--   
--   If any of the dims in <tt>as</tt> or <tt>b</tt> is unknown (<tt>a ~ XN
--   m</tt>), then this function is unsafe and can throw an
--   <a>OutOfDimBounds</a> exception. Otherwise, its safety is guaranteed
--   by the type system.
subDataFrameView :: forall (t :: Type) b bi bd as bs asbs s. (SubFrameIndexCtx b bi bd, KnownDim bd, ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> STDataFrame s t asbs -> STDataFrame s t (bd :+ bs)

-- | View a part of a DataFrame.
--   
--   This function does not perform a copy. All changes to a new DataFrame
--   will be reflected in the original DataFrame as well.
--   
--   This is a simpler version of <tt>subDataFrameView</tt> that allows to
--   view over one index at a time.
--   
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
subDataFrameView' :: forall (t :: Type) as bs asbs s. ConcatList as bs asbs => Idxs as -> STDataFrame s t asbs -> STDataFrame s t bs

-- | Copy one DataFrame into another mutable DataFrame at specified
--   position.
--   
--   In contrast to <tt>copyDataFrame'</tt>, this function allows to copy
--   over a range of contiguous indices over a single dimension. For
--   example, you can write a 3x4 matrix into a 7x4 matrix, starting at
--   indices 0..3.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing. If (<tt>b ~ XN m</tt>) and (<tt>Idx bi + Dim bd
--   &gt; Dim b</tt>), this function copies only as many elements as fits
--   into the dataframe along this dimension (possibly none).
copyDataFrame :: forall (t :: Type) b bi bd as bs asbs s. (SubFrameIndexCtx b bi bd, KnownDim bd, ExactDims bs, PrimArray t (DataFrame t (bd :+ bs)), ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> DataFrame t (bd :+ bs) -> STDataFrame s t asbs -> ST s ()

-- | Copy one mutable DataFrame into another mutable DataFrame at specified
--   position.
--   
--   In contrast to <tt>copyMutableDataFrame'</tt>, this function allows to
--   copy over a range of contiguous indices over a single dimension. For
--   example, you can write a 3x4 matrix into a 7x4 matrix, starting at
--   indices 0..3.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing. If (<tt>b ~ XN m</tt>) and (<tt>Idx bi + Dim bd
--   &gt; Dim b</tt>), this function copies only as many elements as fits
--   into the dataframe along this dimension (possibly none).
copyMutableDataFrame :: forall (t :: Type) b bi bd as bs asbs s. (SubFrameIndexCtx b bi bd, ExactDims bs, PrimBytes t, ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> STDataFrame s t (bd :+ bs) -> STDataFrame s t asbs -> ST s ()

-- | Copy one DataFrame into another mutable DataFrame at specified
--   position.
--   
--   This is a simpler version of <tt>copyDataFrame</tt> that allows to
--   copy over one index at a time.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
copyDataFrame' :: forall (t :: Type) as bs asbs s. (ExactDims bs, PrimArray t (DataFrame t bs), ConcatList as bs asbs) => Idxs as -> DataFrame t bs -> STDataFrame s t asbs -> ST s ()

-- | Copy one mutable DataFrame into another mutable DataFrame at specified
--   position.
--   
--   This is a simpler version of <tt>copyMutableDataFrame</tt> that allows
--   to copy over one index at a time.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
copyMutableDataFrame' :: forall (t :: Type) as bs asbs s. (ExactDims bs, PrimBytes t, ConcatList as bs asbs) => Idxs as -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()

-- | Copy one DataFrame into another mutable DataFrame by offset in
--   primitive elements.
--   
--   This is a low-level copy function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds.
copyDataFrameOff :: forall (t :: Type) as bs asbs s. (Dimensions bs, PrimArray t (DataFrame t bs), ConcatList as bs asbs) => Int -> DataFrame t bs -> STDataFrame s t asbs -> ST s ()

-- | Copy one mutable DataFrame into another mutable DataFrame by offset in
--   primitive elements.
--   
--   This is a low-level copy function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds
copyMutableDataFrameOff :: forall (t :: Type) as bs asbs s. (ExactDims bs, PrimBytes t, ConcatList as bs asbs) => Int -> STDataFrame s t bs -> STDataFrame s t asbs -> ST s ()

-- | Copy content of a mutable DataFrame into a new immutable DataFrame.
freezeDataFrame :: forall (t :: Type) ns s. PrimArray t (DataFrame t ns) => STDataFrame s t ns -> ST s (DataFrame t ns)

-- | Make a mutable DataFrame immutable, without copying.
unsafeFreezeDataFrame :: forall (t :: Type) ns s. PrimArray t (DataFrame t ns) => STDataFrame s t ns -> ST s (DataFrame t ns)

-- | Create a new mutable DataFrame and copy content of immutable one in
--   there.
thawDataFrame :: forall (t :: Type) ns s. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> ST s (STDataFrame s t ns)

-- | Create a new mutable DataFrame and copy content of immutable one in
--   there. The result array is pinned and aligned.
thawPinDataFrame :: forall (t :: Type) ns s. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> ST s (STDataFrame s t ns)

-- | UnsafeCoerces an underlying byte array.
unsafeThawDataFrame :: forall (t :: Type) ns s. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> ST s (STDataFrame s t ns)

-- | Given two continuations <tt>f</tt> and <tt>g</tt>. If the input
--   DataFrame is a single broadcast value, use it in <tt>f</tt>.
--   Otherwise, create a new mutable DataFrame and copy content of
--   immutable one in there; then use it in <tt>g</tt>.
--   
--   This function is useful when <tt>thawDataFrame</tt> cannot be used due
--   to <tt>Dimensions ns</tt> constraint being not available.
withThawDataFrame :: forall (t :: Type) ns r s. PrimArray t (DataFrame t ns) => (t -> ST s r) -> (STDataFrame s t ns -> ST s r) -> DataFrame t ns -> ST s r

-- | Write a single element at the specified index.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
writeDataFrame :: forall (t :: Type) ns s. PrimBytes (DataFrame t ('[] :: KindOf ns)) => STDataFrame s t ns -> Idxs ns -> DataFrame t ('[] :: KindOf ns) -> ST s ()

-- | Write a single element at the specified element offset.
--   
--   This is a low-level write function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds.
writeDataFrameOff :: forall (t :: Type) ns s. PrimBytes (DataFrame t ('[] :: KindOf ns)) => STDataFrame s t ns -> Int -> DataFrame t ('[] :: KindOf ns) -> ST s ()

-- | Read a single element at the specified index.
--   
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
readDataFrame :: forall (t :: Type) ns s. PrimBytes (DataFrame t ('[] :: KindOf ns)) => STDataFrame s t ns -> Idxs ns -> ST s (DataFrame t ('[] :: KindOf ns))

-- | Read a single element at the specified element offset.
--   
--   This is a low-level read function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you read beyond the DataFrame
--   bounds.
readDataFrameOff :: forall (t :: Type) ns s. PrimBytes (DataFrame t ('[] :: KindOf ns)) => STDataFrame s t ns -> Int -> ST s (DataFrame t ('[] :: KindOf ns))

-- | Check if the byte array wrapped by this DataFrame is pinned, which
--   means cannot be relocated by GC.
isDataFramePinned :: forall (t :: Type) ns s. STDataFrame s t ns -> Bool

-- | Get cumulative dimensions <tt>ns</tt> of a <tt>STDataFrame s t ns</tt>
getDataFrameSteps :: forall (t :: Type) ns s. STDataFrame s t ns -> CumulDims


-- | This module provides a flexible interface to manipulate parts of a
--   DataFrame.
--   
--   <h4>A note on indexing and slicing</h4>
--   
--   When you index or slice dataframes, the left part of the dimension
--   list (<tt>as</tt> for indexing, plus <tt>b</tt> for slicing)
--   determines the mechanics of accessing sub-dataframes. If compiler
--   knows all dimensions at compile time, it can guarantee that the
--   operation is safe (provided with valid indices). Otherwise, you can
--   get an <a>OutOfDimBounds</a> exception at runtime.
--   
--   When all dimensions in the indexing subspace satisfy <tt>d :: Nat</tt>
--   or <tt>d ~ N n</tt>, slicing functions are safe to use, but you need
--   some type-level proof for GHC that the indices align.
--   
--   When any of the dimensions are unknown (<tt>d ~ XN m</tt>), these
--   functions are unsafe -- they can yield an <a>OutOfDimBounds</a>
--   exception if you give a bad index. But they are easy to use (no
--   type-level proof needed).
module Numeric.DataFrame.SubSpace

-- | Operations on DataFrames
--   
--   <tt>as</tt> is an indexing dimensionality
--   
--   <tt>bs</tt> is an element dimensionality
--   
--   <tt>t</tt> is an underlying data type (i.e. Float, Int, Double)
class (ConcatList as bs asbs, SubSpaceCtx t as bs asbs, PrimBytes t, KnownDimKind k) => SubSpace (t :: Type) (as :: [k]) (bs :: [k]) (asbs :: [k]) | asbs as -> bs, asbs bs -> as, as bs -> asbs where {
    type family SubSpaceCtx t as bs asbs :: Constraint;
}

-- | DataFrames indexed by Nats and XNats require slightly different sets
--   of constraints to be sliced. This family hides the difference, so that
--   I could write one function for both kinds.
type family CanSlice (t :: Type) (asbs :: [k]) :: Constraint

-- | Unsafely get a sub-dataframe by its primitive element offset. The
--   offset is not checked to be aligned to the space structure or for
--   bounds.
--   
--   Warning: this function is utterly unsafe -- it does not even throw an
--   exception if the offset is too big; you just get an undefined
--   behavior.
sindexOffset :: forall t a bs. SubSpace t '[a] bs (a :+ bs) => Int -> DataFrame t (a :+ bs) -> DataFrame t bs

-- | Unsafely update a sub-dataframe by its primitive element offset. The
--   offset is not checked to be aligned to the space structure or for
--   bounds.
--   
--   Warning: this function is utterly unsafe -- it does not even throw an
--   exception if the offset is too big; you just get an undefined
--   behavior.
supdateOffset :: forall t a bs. SubSpace t '[a] bs (a :+ bs) => Int -> DataFrame t bs -> DataFrame t (a :+ bs) -> DataFrame t (a :+ bs)

-- | Get an element by its index in the dataframe.
--   
--   If (<tt>a ~ XN m</tt>) then this function is unsafe and can throw an
--   <a>OutOfDimBounds</a> exception. Otherwise, its safety is guaranteed
--   by the type system.
(.!) :: forall t a bs. SubSpace t '[a] bs (a :+ bs) => DataFrame t (a :+ bs) -> Idx a -> DataFrame t bs
infixl 4 .!

-- | Get an element by its index in the dataframe. This is a safe
--   alternative to `(.!)` function when the index dimension is not known
--   at compile time (<tt>a ~ XN m</tt>).
slookup :: forall t (a :: XNat) (bs :: [XNat]). (All KnownDimType bs, PrimBytes t) => Idx a -> DataFrame t (a :+ bs) -> Maybe (DataFrame t bs)

-- | Set a new value to an element.
--   
--   If (<tt>a ~ XN m</tt>) and the index falls outside of the DataFrame
--   dim, then this function returns the original DataFrame.
supdate :: forall t a bs. SubSpace t '[a] bs (a :+ bs) => Idx a -> DataFrame t bs -> DataFrame t (a :+ bs) -> DataFrame t (a :+ bs)

-- | Get a few contiguous elements.
--   
--   In a sense, this is just a more complicated version of
--   <tt>sindex</tt>.
--   
--   If (<tt>b ~ XN m</tt>) then this function is unsafe and can throw an
--   <a>OutOfDimBounds</a> exception. Otherwise, its safety is guaranteed
--   by the type system.
sslice :: forall t b bi bd bs. (KnownDimKind (KindOfEl bs), CanSlice t (b :+ bs), SubFrameIndexCtx b bi bd, KnownDim bd, PrimArray t (DataFrame t (bd :+ bs))) => Idx bi -> DataFrame t (b :+ bs) -> DataFrame t (bd :+ bs)

-- | Get a few contiguous elements.
--   
--   In a sense, this is just a more complicated version of <a>slookup</a>.
--   
--   This is a safe alternative to <a>sslice</a> function when the slice
--   dimension is not known at compile time (<tt>b ~ XN m</tt>).
ssliceMaybe :: forall (t :: Type) (b :: XNat) (bi :: XNat) (bd :: XNat) (bs :: [XNat]). (SubFrameIndexCtx b bi bd, KnownDim bd, All KnownDimType bs, PrimBytes t) => Idx bi -> DataFrame t (b :+ bs) -> Maybe (DataFrame t (bd :+ bs))

-- | Update a few contiguous elements.
--   
--   In a sense, this is just a more complicated version of <a>supdate</a>.
--   
--   If (<tt>b ~ XN m</tt>) and (<tt>Idx bi + Dim bd &gt; Dim b</tt>), this
--   function updates only as many elements as fits into the dataframe
--   along this dimension (possibly none).
supdateSlice :: forall t b bi bd bs. (KnownDimKind (KindOfEl bs), CanSlice t (b :+ bs), SubFrameIndexCtx b bi bd, KnownDim bd, ExactDims bs, PrimArray t (DataFrame t (bd :+ bs))) => Idx bi -> DataFrame t (bd :+ bs) -> DataFrame t (b :+ bs) -> DataFrame t (b :+ bs)

-- | Generate a DataFrame by repeating an element.
sewgen :: forall t a bs. (SubSpace t '[a] bs (a :+ bs), Dimensions '[a]) => DataFrame t bs -> DataFrame t (a :+ bs)

-- | Generate a DataFrame by iterating a function (index -&gt; element).
siwgen :: forall t a bs. (SubSpace t '[a] bs (a :+ bs), Dimensions '[a]) => (Idx a -> DataFrame t bs) -> DataFrame t (a :+ bs)

-- | Map a function over each element of DataFrame.
sewmap :: forall t a bs s bs'. (SubSpace t '[a] bs (a :+ bs), SubSpace s '[a] bs' (a :+ bs')) => (DataFrame s bs' -> DataFrame t bs) -> DataFrame s (a :+ bs') -> DataFrame t (a :+ bs)

-- | Map a function over each element with its index of DataFrame.
siwmap :: forall t a bs s bs'. (SubSpace t '[a] bs (a :+ bs), SubSpace s '[a] bs' (a :+ bs')) => (Idx a -> DataFrame s bs' -> DataFrame t bs) -> DataFrame s (a :+ bs') -> DataFrame t (a :+ bs)

-- | Zip two spaces on a specified subspace element-wise (without index)
sewzip :: forall t a bs l bsL r bsR. (SubSpace t '[a] bs (a :+ bs), SubSpace l '[a] bsL (a :+ bsL), SubSpace r '[a] bsR (a :+ bsR)) => (DataFrame l bsL -> DataFrame r bsR -> DataFrame t bs) -> DataFrame l (a :+ bsL) -> DataFrame r (a :+ bsR) -> DataFrame t (a :+ bs)

-- | Zip two spaces on a specified subspace index-wise (with index)
siwzip :: forall t a bs l bsL r bsR. (SubSpace t '[a] bs (a :+ bs), SubSpace l '[a] bsL (a :+ bsL), SubSpace r '[a] bsR (a :+ bsR)) => (Idx a -> DataFrame l bsL -> DataFrame r bsR -> DataFrame t bs) -> DataFrame l (a :+ bsL) -> DataFrame r (a :+ bsR) -> DataFrame t (a :+ bs)

-- | Apply a functor over a single element (simple lens)
--   
--   If (<tt>a ~ XN m</tt>) and the index falls outside of the DataFrame
--   Dim, the argument Functor is not called and the result is
--   <tt>pure</tt> original DataFrame.
selement :: forall t a bs f. (SubSpace t '[a] bs (a :+ bs), Applicative f) => Idx a -> (DataFrame t bs -> f (DataFrame t bs)) -> DataFrame t (a :+ bs) -> f (DataFrame t (a :+ bs))

-- | Apply an applicative functor on each element (Lens-like traversal).
selementWise :: forall t a bs s bs' f. (SubSpace t '[a] bs (a :+ bs), SubSpace s '[a] bs' (a :+ bs'), Applicative f) => (DataFrame s bs' -> f (DataFrame t bs)) -> DataFrame s (a :+ bs') -> f (DataFrame t (a :+ bs))

-- | Apply an applicative functor on each element (Lens-like traversal)
selementWise_ :: forall t a bs f b. (SubSpace t '[a] bs (a :+ bs), Applicative f) => (DataFrame t bs -> f b) -> DataFrame t (a :+ bs) -> f ()

-- | Apply an applicative functor on each element with its index (Lens-like
--   indexed traversal).
sindexWise :: forall t a bs s bs' f. (SubSpace t '[a] bs (a :+ bs), SubSpace s '[a] bs' (a :+ bs'), Applicative f) => (Idx a -> DataFrame s bs' -> f (DataFrame t bs)) -> DataFrame s (a :+ bs') -> f (DataFrame t (a :+ bs))

-- | Apply an applicative functor on each element with its index (Lens-like
--   indexed traversal)
sindexWise_ :: forall t a bs f b. (SubSpace t '[a] bs (a :+ bs), Applicative f) => (Idx a -> DataFrame t bs -> f b) -> DataFrame t (a :+ bs) -> f ()

-- | Left-associative lazy fold of a DataFrame. Same rules apply as for
--   <a>foldl</a>.
sewfoldl :: forall t a bs b. SubSpace t '[a] bs (a :+ bs) => (b -> DataFrame t bs -> b) -> b -> DataFrame t (a :+ bs) -> b

-- | Left-associative strict fold of a DataFrame. Same rules apply as for
--   <tt>foldl'</tt>.
sewfoldl' :: forall t a bs b. SubSpace t '[a] bs (a :+ bs) => (b -> DataFrame t bs -> b) -> b -> DataFrame t (a :+ bs) -> b

-- | Right-associative lazy fold of a DataFrame. Same rules apply as for
--   <a>foldr</a>.
sewfoldr :: forall t a bs b. SubSpace t '[a] bs (a :+ bs) => (DataFrame t bs -> b -> b) -> b -> DataFrame t (a :+ bs) -> b

-- | Right-associative strict fold of a DataFrame. Same rules apply as for
--   <tt>foldr'</tt>.
sewfoldr' :: forall t a bs b. SubSpace t '[a] bs (a :+ bs) => (DataFrame t bs -> b -> b) -> b -> DataFrame t (a :+ bs) -> b

-- | Map each element of the DataFrame to a monoid, and combine the
--   results.
sewfoldMap :: forall t a bs m. (SubSpace t '[a] bs (a :+ bs), Monoid m) => (DataFrame t bs -> m) -> DataFrame t (a :+ bs) -> m

-- | Left-associative lazy fold of a DataFrame with an index. Same rules
--   apply as for <a>foldl</a>.
siwfoldl :: forall t a bs b. SubSpace t '[a] bs (a :+ bs) => (Idx a -> b -> DataFrame t bs -> b) -> b -> DataFrame t (a :+ bs) -> b

-- | Left-associative strict fold of a DataFrame with an index. Same rules
--   apply as for <tt>foldl'</tt>.
siwfoldl' :: forall t a bs b. SubSpace t '[a] bs (a :+ bs) => (Idx a -> b -> DataFrame t bs -> b) -> b -> DataFrame t (a :+ bs) -> b

-- | Right-associative lazy fold of a DataFrame with an index. Same rules
--   apply as for <a>foldr</a>.
siwfoldr :: forall t a bs b. SubSpace t '[a] bs (a :+ bs) => (Idx a -> DataFrame t bs -> b -> b) -> b -> DataFrame t (a :+ bs) -> b

-- | Right-associative strict fold of a DataFrame with an index. Same rules
--   apply as for <tt>foldr'</tt>.
siwfoldr' :: forall t a bs b. SubSpace t '[a] bs (a :+ bs) => (Idx a -> DataFrame t bs -> b -> b) -> b -> DataFrame t (a :+ bs) -> b

-- | Map each element of the DataFrame and its index to a monoid, and
--   combine the results.
siwfoldMap :: forall t a bs m. (SubSpace t '[a] bs (a :+ bs), Monoid m) => (Idx a -> DataFrame t bs -> m) -> DataFrame t (a :+ bs) -> m

-- | Flatten a nested DataFrame, analogous to <a>join</a>.
joinDataFrame :: forall t as bs asbs. (SubSpace t as bs asbs, PrimBytes (DataFrame t bs)) => DataFrame (DataFrame t bs) as -> DataFrame t asbs

-- | Unsafely get a sub-dataframe by its primitive element offset. The
--   offset is not checked to be aligned to the space structure or for
--   bounds.
--   
--   Warning: this function is utterly unsafe -- it does not even throw an
--   exception if the offset is too big; you just get an undefined
--   behavior.
indexOffset :: forall t as bs asbs. SubSpace t as bs asbs => Int -> DataFrame t asbs -> DataFrame t bs

-- | Unsafely update a sub-dataframe by its primitive element offset. The
--   offset is not checked to be aligned to the space structure or for
--   bounds.
--   
--   Warning: this function is utterly unsafe -- it does not even throw an
--   exception if the offset is too big; you just get an undefined
--   behavior.
updateOffset :: forall t as bs asbs. SubSpace t as bs asbs => Int -> DataFrame t bs -> DataFrame t asbs -> DataFrame t asbs

-- | Get an element by its index in the dataframe.
--   
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
index :: forall t as bs asbs. SubSpace t as bs asbs => Idxs as -> DataFrame t asbs -> DataFrame t bs

-- | Get an element by its index in the dataframe. This is a safe
--   alternative to <a>index</a> function when some of the dimensions are
--   not known at compile time (<tt>d ~ XN m</tt>).
lookup :: forall t (as :: [XNat]) (bs :: [XNat]) (asbs :: [XNat]). (ConcatList as bs asbs, All KnownDimType bs, PrimBytes t) => Idxs as -> DataFrame t asbs -> Maybe (DataFrame t bs)

-- | Set a new value to an element.
--   
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to update data beyond dataframe bounds. In this case, the
--   original DataFrame is returned.
update :: forall t as bs asbs. SubSpace t as bs asbs => Idxs as -> DataFrame t bs -> DataFrame t asbs -> DataFrame t asbs

-- | Get a few contiguous elements.
--   
--   In a sense, this is just a more complicated version of <a>index</a>.
--   
--   If any of the dims in <tt>as</tt> or <tt>b</tt> is unknown (<tt>a ~ XN
--   m</tt>), then this function is unsafe and can throw an
--   <a>OutOfDimBounds</a> exception. Otherwise, its safety is guaranteed
--   by the type system.
slice :: forall (t :: Type) b bi bd as bs asbs. (KnownDimKind (KindOfEl asbs), CanSlice t asbs, SubFrameIndexCtx b bi bd, KnownDim bd, ConcatList as (b :+ bs) asbs, PrimArray t (DataFrame t (bd :+ bs))) => Idxs (as +: bi) -> DataFrame t asbs -> DataFrame t (bd :+ bs)

-- | Get a few contiguous elements.
--   
--   In a sense, this is just a more complicated version of <a>lookup</a>.
--   
--   This is a safe alternative to <a>slice</a> function when some of the
--   dimensions are not known at compile time (<tt>d ~ XN m</tt>).
sliceMaybe :: forall (t :: Type) (b :: XNat) bi bd as bs asbs. (SubFrameIndexCtx b bi bd, KnownDim bd, ConcatList as (b :+ bs) asbs, All KnownDimType bs, PrimBytes t) => Idxs (as +: bi) -> DataFrame t asbs -> Maybe (DataFrame t (bd :+ bs))

-- | Update a few contiguous elements.
--   
--   In a sense, this is just a more complicated version of <a>update</a>.
--   
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to update data beyond dataframe bounds. In this case, the
--   original DataFrame is returned. If (<tt>b ~ XN m</tt>) and (<tt>Idx bi
--   + Dim bd &gt; Dim b</tt>), this function updates only as many elements
--   as fits into the dataframe along this dimension (possibly none).
updateSlice :: forall (t :: Type) b bi bd as bs asbs. (KnownDimKind (KindOfEl asbs), CanSlice t asbs, SubFrameIndexCtx b bi bd, KnownDim bd, ExactDims bs, ConcatList as (b :+ bs) asbs, PrimArray t (DataFrame t (bd :+ bs))) => Idxs (as +: bi) -> DataFrame t (bd :+ bs) -> DataFrame t asbs -> DataFrame t asbs

-- | Generate a DataFrame by repeating an element.
ewgen :: forall t as bs asbs. (SubSpace t as bs asbs, Dimensions as) => DataFrame t bs -> DataFrame t asbs

-- | Generate a DataFrame by iterating a function (index -&gt; element).
iwgen :: forall t as bs asbs. (SubSpace t as bs asbs, Dimensions as) => (Idxs as -> DataFrame t bs) -> DataFrame t asbs

-- | Map a function over each element of DataFrame.
ewmap :: forall t as bs asbs s bs' asbs'. (SubSpace t as bs asbs, SubSpace s as bs' asbs') => (DataFrame s bs' -> DataFrame t bs) -> DataFrame s asbs' -> DataFrame t asbs

-- | Map a function over each element with its index of DataFrame.
iwmap :: forall t as bs asbs s bs' asbs'. (SubSpace t as bs asbs, SubSpace s as bs' asbs') => (Idxs as -> DataFrame s bs' -> DataFrame t bs) -> DataFrame s asbs' -> DataFrame t asbs

-- | Zip two spaces on a specified subspace element-wise (without index)
ewzip :: forall t as bs asbs l bsL asbsL r bsR asbsR. (SubSpace t as bs asbs, SubSpace l as bsL asbsL, SubSpace r as bsR asbsR) => (DataFrame l bsL -> DataFrame r bsR -> DataFrame t bs) -> DataFrame l asbsL -> DataFrame r asbsR -> DataFrame t asbs

-- | Zip two spaces on a specified subspace index-wise (with index).
iwzip :: forall t as bs asbs l bsL asbsL r bsR asbsR. (SubSpace t as bs asbs, SubSpace l as bsL asbsL, SubSpace r as bsR asbsR) => (Idxs as -> DataFrame l bsL -> DataFrame r bsR -> DataFrame t bs) -> DataFrame l asbsL -> DataFrame r asbsR -> DataFrame t asbs

-- | Apply a functor over a single element (simple lens)
--   
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>) and
--   any of the corresponding indices fall outside of the DataFrame Dims,
--   then the argument Functor is not called and the result is
--   <tt>pure</tt> original DataFrame.
element :: forall t as bs asbs f. (SubSpace t as bs asbs, Applicative f) => Idxs as -> (DataFrame t bs -> f (DataFrame t bs)) -> DataFrame t asbs -> f (DataFrame t asbs)

-- | Apply an applicative functor on each element (Lens-like traversal).
elementWise :: forall t as bs asbs s bs' asbs' f. (SubSpace t as bs asbs, SubSpace s as bs' asbs', Applicative f) => (DataFrame s bs' -> f (DataFrame t bs)) -> DataFrame s asbs' -> f (DataFrame t asbs)

-- | Apply an applicative functor on each element (Lens-like traversal)
elementWise_ :: forall t as bs asbs f b. (SubSpace t as bs asbs, Applicative f) => (DataFrame t bs -> f b) -> DataFrame t asbs -> f ()

-- | Apply an applicative functor on each element with its index (Lens-like
--   indexed traversal).
indexWise :: forall t as bs asbs s bs' asbs' f. (SubSpace t as bs asbs, SubSpace s as bs' asbs', Applicative f) => (Idxs as -> DataFrame s bs' -> f (DataFrame t bs)) -> DataFrame s asbs' -> f (DataFrame t asbs)

-- | Apply an applicative functor on each element with its index (Lens-like
--   indexed traversal)
indexWise_ :: forall t as bs asbs f b. (SubSpace t as bs asbs, Applicative f) => (Idxs as -> DataFrame t bs -> f b) -> DataFrame t asbs -> f ()

-- | Left-associative lazy fold of a DataFrame. Same rules apply as for
--   <a>foldl</a>.
ewfoldl :: forall t as bs asbs b. SubSpace t as bs asbs => (b -> DataFrame t bs -> b) -> b -> DataFrame t asbs -> b

-- | Left-associative strict fold of a DataFrame. Same rules apply as for
--   <tt>foldl'</tt>.
ewfoldl' :: forall t as bs asbs b. SubSpace t as bs asbs => (b -> DataFrame t bs -> b) -> b -> DataFrame t asbs -> b

-- | Right-associative lazy fold of a DataFrame. Same rules apply as for
--   <a>foldr</a>.
ewfoldr :: forall t as bs asbs b. SubSpace t as bs asbs => (DataFrame t bs -> b -> b) -> b -> DataFrame t asbs -> b

-- | Right-associative strict fold of a DataFrame. Same rules apply as for
--   <tt>foldr'</tt>.
ewfoldr' :: forall t as bs asbs b. SubSpace t as bs asbs => (DataFrame t bs -> b -> b) -> b -> DataFrame t asbs -> b

-- | Map each element of the DataFrame to a monoid, and combine the
--   results.
ewfoldMap :: forall t as bs asbs m. (SubSpace t as bs asbs, Monoid m) => (DataFrame t bs -> m) -> DataFrame t asbs -> m

-- | Left-associative lazy fold of a DataFrame with an index. Same rules
--   apply as for <a>foldl</a>.
iwfoldl :: forall t as bs asbs b. SubSpace t as bs asbs => (Idxs as -> b -> DataFrame t bs -> b) -> b -> DataFrame t asbs -> b

-- | Left-associative strict fold of a DataFrame with an index. Same rules
--   apply as for <tt>foldl'</tt>.
iwfoldl' :: forall t as bs asbs b. SubSpace t as bs asbs => (Idxs as -> b -> DataFrame t bs -> b) -> b -> DataFrame t asbs -> b

-- | Right-associative lazy fold of a DataFrame with an index. Same rules
--   apply as for <a>foldr</a>.
iwfoldr :: forall t as bs asbs b. SubSpace t as bs asbs => (Idxs as -> DataFrame t bs -> b -> b) -> b -> DataFrame t asbs -> b

-- | Right-associative strict fold of a DataFrame with an index. Same rules
--   apply as for <tt>foldr'</tt>.
iwfoldr' :: forall t as bs asbs b. SubSpace t as bs asbs => (Idxs as -> DataFrame t bs -> b -> b) -> b -> DataFrame t asbs -> b

-- | Map each element of the DataFrame and its index to a monoid, and
--   combine the results.
iwfoldMap :: forall t as bs asbs m. (SubSpace t as bs asbs, Monoid m) => (Idxs as -> DataFrame t bs -> m) -> DataFrame t asbs -> m
instance (Data.Type.List.Classes.ConcatList as bs asbs, Numeric.DataFrame.SubSpace.SubSpaceCtx t as bs asbs) => Numeric.DataFrame.SubSpace.SubSpace t as bs asbs
instance (Data.Type.List.Classes.ConcatList as bs asbs, Numeric.DataFrame.SubSpace.SubSpaceCtx t as bs asbs) => Numeric.DataFrame.SubSpace.SubSpace t as bs asbs


-- | Mutable DataFrames living in IO.
module Numeric.DataFrame.IO

-- | Mutable DataFrame that lives in IO. Internal representation is always
--   a MutableByteArray.
data IODataFrame (t :: Type) (ns :: [k])

-- | Data frame with some dimensions missing at compile time. Pattern-match
--   against its constructor to get a Nat-indexed mutable data frame.
pattern XIOFrame :: forall (t :: Type) (xns :: [XNat]). () => forall (ns :: [Nat]). (FixedDims xns ns, Dimensions ns) => IODataFrame t ns -> IODataFrame t xns

-- | Mutable DataFrame of unknown dimensionality
data SomeIODataFrame (t :: Type)
SomeIODataFrame :: IODataFrame t ns -> SomeIODataFrame

-- | Allow coercing between <tt>XNat</tt>-indexed and <tt>Nat</tt>-indexed
--   Mutable DataFrames.
castDataFrame :: forall (t :: Type) (xns :: [XNat]) (ns :: [Nat]). FixedDims xns ns => IODataFrame t ns -> IODataFrame t xns

-- | Create a new mutable DataFrame.
newDataFrame :: forall (t :: Type) ns. (PrimBytes t, Dimensions ns) => IO (IODataFrame t ns)

-- | Create a new mutable DataFrame.
newPinnedDataFrame :: forall (t :: Type) ns. (PrimBytes t, Dimensions ns) => IO (IODataFrame t ns)

-- | Create a new mutable DataFrame of the same size.
oneMoreDataFrame :: forall (t :: Type) ns. IODataFrame t ns -> IO (IODataFrame t ns)

-- | View a part of a DataFrame.
--   
--   This function does not perform a copy. All changes to a new DataFrame
--   will be reflected in the original DataFrame as well.
--   
--   If any of the dims in <tt>as</tt> or <tt>b</tt> is unknown (<tt>a ~ XN
--   m</tt>), then this function is unsafe and can throw an
--   <a>OutOfDimBounds</a> exception. Otherwise, its safety is guaranteed
--   by the type system.
subDataFrameView :: forall (t :: Type) b bi bd as bs asbs. (SubFrameIndexCtx b bi bd, KnownDim bd, ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> IODataFrame t asbs -> IODataFrame t (bd :+ bs)

-- | View a part of a DataFrame.
--   
--   This function does not perform a copy. All changes to a new DataFrame
--   will be reflected in the original DataFrame as well.
--   
--   This is a simpler version of <tt>subDataFrameView</tt> that allows to
--   view over one index at a time.
--   
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
subDataFrameView' :: forall (t :: Type) as bs asbs. ConcatList as bs asbs => Idxs as -> IODataFrame t asbs -> IODataFrame t bs

-- | Copy one DataFrame into another mutable DataFrame at specified
--   position.
--   
--   In contrast to <tt>copyDataFrame'</tt>, this function allows to copy
--   over a range of contiguous indices over a single dimension. For
--   example, you can write a 3x4 matrix into a 7x4 matrix, starting at
--   indices 0..3.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing. If (<tt>b ~ XN m</tt>) and (<tt>Idx bi + Dim bd
--   &gt; Dim b</tt>), this function copies only as many elements as fits
--   into the dataframe along this dimension (possibly none).
copyDataFrame :: forall (t :: Type) b bi bd as bs asbs. (SubFrameIndexCtx b bi bd, KnownDim bd, ExactDims bs, PrimArray t (DataFrame t (bd :+ bs)), ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> DataFrame t (bd :+ bs) -> IODataFrame t asbs -> IO ()

-- | Copy one mutable DataFrame into another mutable DataFrame at specified
--   position.
--   
--   In contrast to <tt>copyMutableDataFrame'</tt>, this function allows to
--   copy over a range of contiguous indices over a single dimension. For
--   example, you can write a 3x4 matrix into a 7x4 matrix, starting at
--   indices 0..3.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing. If (<tt>b ~ XN m</tt>) and (<tt>Idx bi + Dim bd
--   &gt; Dim b</tt>), this function copies only as many elements as fits
--   into the dataframe along this dimension (possibly none).
copyMutableDataFrame :: forall (t :: Type) b bi bd as bs asbs. (SubFrameIndexCtx b bi bd, ExactDims bs, PrimBytes t, ConcatList as (b :+ bs) asbs) => Idxs (as +: bi) -> IODataFrame t (bd :+ bs) -> IODataFrame t asbs -> IO ()

-- | Copy one DataFrame into another mutable DataFrame at specified
--   position.
--   
--   This is a simpler version of <tt>copyDataFrame</tt> that allows to
--   copy over one index at a time.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
copyDataFrame' :: forall (t :: Type) as bs asbs. (ExactDims bs, PrimArray t (DataFrame t bs), ConcatList as bs asbs) => Idxs as -> DataFrame t bs -> IODataFrame t asbs -> IO ()

-- | Copy one mutable DataFrame into another mutable DataFrame at specified
--   position.
--   
--   This is a simpler version of <tt>copyMutableDataFrame</tt> that allows
--   to copy over one index at a time.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>as</tt> is unknown (<tt>a ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
copyMutableDataFrame' :: forall (t :: Type) as bs asbs. (ExactDims bs, PrimBytes t, ConcatList as bs asbs) => Idxs as -> IODataFrame t bs -> IODataFrame t asbs -> IO ()

-- | Copy one DataFrame into another mutable DataFrame by offset in
--   primitive elements.
--   
--   This is a low-level copy function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds.
copyDataFrameOff :: forall (t :: Type) as bs asbs. (Dimensions bs, PrimArray t (DataFrame t bs), ConcatList as bs asbs) => Int -> DataFrame t bs -> IODataFrame t asbs -> IO ()

-- | Copy one mutable DataFrame into another mutable DataFrame by offset in
--   primitive elements.
--   
--   This is a low-level copy function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds
copyMutableDataFrameOff :: forall (t :: Type) as bs asbs. (ExactDims bs, PrimBytes t, ConcatList as bs asbs) => Int -> IODataFrame t bs -> IODataFrame t asbs -> IO ()

-- | Copy content of a mutable DataFrame into a new immutable DataFrame.
freezeDataFrame :: forall (t :: Type) ns. PrimArray t (DataFrame t ns) => IODataFrame t ns -> IO (DataFrame t ns)

-- | Make a mutable DataFrame immutable, without copying.
unsafeFreezeDataFrame :: forall (t :: Type) ns. PrimArray t (DataFrame t ns) => IODataFrame t ns -> IO (DataFrame t ns)

-- | Create a new mutable DataFrame and copy content of immutable one in
--   there.
thawDataFrame :: forall (t :: Type) ns. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> IO (IODataFrame t ns)

-- | Create a new mutable DataFrame and copy content of immutable one in
--   there. The result array is pinned and aligned.
thawPinDataFrame :: forall (t :: Type) ns. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> IO (IODataFrame t ns)

-- | UnsafeCoerces an underlying byte array.
unsafeThawDataFrame :: forall (t :: Type) ns. (Dimensions ns, PrimArray t (DataFrame t ns)) => DataFrame t ns -> IO (IODataFrame t ns)

-- | Given two continuations <tt>f</tt> and <tt>g</tt>. If the input
--   DataFrame is a single broadcast value, use it in <tt>f</tt>.
--   Otherwise, create a new mutable DataFrame and copy content of
--   immutable one in there; then use it in <tt>g</tt>.
--   
--   This function is useful when <tt>thawDataFrame</tt> cannot be used due
--   to <tt>Dimensions ns</tt> constraint being not available.
withThawDataFrame :: forall (t :: Type) ns r. PrimArray t (DataFrame t ns) => (t -> IO r) -> (IODataFrame t ns -> IO r) -> DataFrame t ns -> IO r

-- | Write a single element at the specified index.
--   
--   This function is safe (no <a>OutOfDimBounds</a> exception possible).
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), you
--   may happen to write data beyond dataframe bounds. In this case, this
--   function does nothing.
writeDataFrame :: forall (t :: Type) ns. PrimBytes (DataFrame t ('[] :: KindOf ns)) => IODataFrame t ns -> Idxs ns -> DataFrame t ('[] :: KindOf ns) -> IO ()

-- | Write a single element at the specified element offset.
--   
--   This is a low-level write function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you write beyond the DataFrame
--   bounds.
writeDataFrameOff :: forall (t :: Type) ns. PrimBytes (DataFrame t ('[] :: KindOf ns)) => IODataFrame t ns -> Int -> DataFrame t ('[] :: KindOf ns) -> IO ()

-- | Read a single element at the specified index.
--   
--   If any of the dims in <tt>ns</tt> is unknown (<tt>n ~ XN m</tt>), then
--   this function is unsafe and can throw an <a>OutOfDimBounds</a>
--   exception. Otherwise, its safety is guaranteed by the type system.
readDataFrame :: forall (t :: Type) ns. PrimBytes (DataFrame t ('[] :: KindOf ns)) => IODataFrame t ns -> Idxs ns -> IO (DataFrame t ('[] :: KindOf ns))

-- | Read a single element at the specified element offset.
--   
--   This is a low-level read function; you have to keep in mind the
--   row-major layout of Mutable DataFrames. Offset bounds are not checked.
--   You will get an undefined behavior if you read beyond the DataFrame
--   bounds.
readDataFrameOff :: forall (t :: Type) ns. PrimBytes (DataFrame t ('[] :: KindOf ns)) => IODataFrame t ns -> Int -> IO (DataFrame t ('[] :: KindOf ns))

-- | Check if the byte array wrapped by this DataFrame is pinned, which
--   means cannot be relocated by GC.
isDataFramePinned :: forall (t :: Type) ns. IODataFrame t ns -> Bool

-- | Get cumulative dimensions <tt>ns</tt> of a <tt>IODataFrame t ns</tt>
getDataFrameSteps :: forall (t :: Type) ns. IODataFrame t ns -> CumulDims

-- | Allow arbitrary IO operations on a pointer to the beginning of the
--   data keeping the data from garbage collecting until the arg function
--   returns.
--   
--   Warning: do not let <tt>Ptr t</tt> leave the scope of the arg
--   function, the data may be garbage-collected by then.
--   
--   Warning: use this function on a pinned DataFrame only; otherwise, the
--   data may be relocated before the arg fun finishes.
withDataFramePtr :: forall (t :: Type) ns (r :: Type). PrimBytes t => IODataFrame t ns -> (Ptr t -> IO r) -> IO r


-- | This modules provides generalization of a matrix product: tensor-like
--   contraction. For matrices and vectors this is a normal matrix*matrix
--   or vector*matrix or matrix*vector product, for larger dimensions it
--   calculates the scalar product of "adjacent" dimesnions of a tensor.
module Numeric.DataFrame.Contraction
class ConcatList as bs asbs => Contraction (t :: Type) (as :: [Nat]) (bs :: [Nat]) (asbs :: [Nat]) | asbs as -> bs, asbs bs -> as, as bs -> asbs

-- | Generalization of a matrix product: take scalar product over one
--   dimension and, thus, concatenate other dimesnions
contract :: (Contraction t as bs asbs, KnownDim m, PrimArray t (DataFrame t (as +: m)), PrimArray t (DataFrame t (m :+ bs)), PrimArray t (DataFrame t asbs)) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t asbs

-- | Tensor contraction. In particular: 1. matrix-matrix product 2.
--   matrix-vector or vector-matrix product 3. dot product of two vectors.
(%*) :: (Contraction t as bs asbs, KnownDim m, PrimArray t (DataFrame t (as +: m)), PrimArray t (DataFrame t (m :+ bs)), PrimArray t (DataFrame t asbs)) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t asbs
infixl 7 %*
instance (Data.Type.List.Classes.ConcatList as bs asbs, Numeric.Dimensions.Dim.Dimensions as, Numeric.Dimensions.Dim.Dimensions bs, GHC.Num.Num t) => Numeric.DataFrame.Contraction.Contraction t as bs asbs

module Numeric.DataFrame.Internal.Backend

-- | A newtype wrapper for all DataFrame implementations. I need two layers
--   of wrappers to provide default overlappable instances to all type
--   classes using KnownBackend mechanics. Type arguments are redundant
--   here; nevertheless, they improve readability of error messages.
newtype Backend (i :: Type) (t :: Type) (ds :: [Nat]) (backend :: Type)
Backend :: backend -> Backend
[_getBackend] :: Backend -> backend

-- | This type family aggregates all types used for arrays with different
--   dimensioinality. The family is injective; thus, it is possible to get
--   type family instance given the data constructor (and vice versa). If
--   GHC knows the dimensionality of a backend at compile time, it chooses
--   a more efficient specialized instance of <tt>BackendFamily</tt>, e.g.
--   Scalar newtype wrapper. Otherwise, it falls back to the generic
--   ArrayBase implementation.
--   
--   Data family would not work here, because it would give overlapping
--   instances.
type family BackendFamily (t :: Type) (ds :: [Nat]) = (v :: Type) | v -> t ds

-- | Backend resolver: Use this constraint to find any class instances
--   defined for all DataFrame implementations, e.g. <tt>Num</tt>,
--   <tt>PrimBytes</tt>, etc.
class KnownBackend t ds (BackendFamily t ds) => KnownBackend (t :: Type) (ds :: [Nat])
inferKnownBackend :: forall (t :: Type) (ds :: [Nat]). (PrimBytes t, Dimensions ds) => Dict (KnownBackend t ds)
inferPrimElem :: forall (t :: Type) (d :: Nat) (ds :: [Nat]) (i :: Type). KnownBackend t (d : ds) => Backend i t (d : ds) (BackendFamily t (d : ds)) -> Dict (PrimBytes t)
inferEq :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Eq t, KnownBackend t ds b) => Dict (Eq (Backend i t ds b))
inferOrd :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Ord t, KnownBackend t ds b) => Dict (Ord (Backend i t ds b))
inferProductOrder :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Ord t, KnownBackend t ds b) => Dict (ProductOrder (Backend i t ds b))
inferPONonTransitive :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Ord t, KnownBackend t ds b) => Dict (Ord (ProductOrd (Backend i t ds b)))
inferPOPartial :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Ord t, KnownBackend t ds b) => Dict (Ord (ProductOrd (Backend i t ds b)))
inferBounded :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Bounded t, KnownBackend t ds b) => Dict (Bounded (Backend i t ds b))
inferNum :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Num t, KnownBackend t ds b) => Dict (Num (Backend i t ds b))
inferFractional :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Fractional t, KnownBackend t ds b) => Dict (Fractional (Backend i t ds b))
inferFloating :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (Floating t, KnownBackend t ds b) => Dict (Floating (Backend i t ds b))
inferPrimBytes :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (PrimBytes t, Dimensions ds, KnownBackend t ds b) => Dict (PrimBytes (Backend i t ds b))
inferPrimArray :: forall (t :: Type) (ds :: [Nat]) (b :: Type) (i :: Type). (PrimBytes t, KnownBackend t ds b) => Dict (PrimArray t (Backend i t ds b))
instance Numeric.DataFrame.Internal.Backend.Family.KnownBackend t ds (Numeric.DataFrame.Internal.Backend.Family.BackendFamily t ds) => Numeric.DataFrame.Internal.Backend.KnownBackend t ds


-- | Scalar is an alias to zero-dimensional DataFrame
module Numeric.Scalar

-- | Alias for zero-dimensional DataFrame
type Scalar t = DataFrame t ('[] :: [Nat])

-- | Convert a scalar back to an ordinary type
unScalar :: DataFrame t ('[] :: [Nat]) -> t

-- | Convert any type to a scalar wrapper
scalar :: t -> DataFrame t ('[] :: [Nat])

-- | Broadcast scalar value onto a whole data frame
fromScalar :: PrimArray t (DataFrame t ds) => Scalar t -> DataFrame t (ds :: [Nat])
type Scf = Scalar Float
type Scd = Scalar Double
type Sci = Scalar Int
type Scw = Scalar Word

module Numeric.Subroutine.Householder

-- | Run a Householder transformation inplace.
--   
--   Similar to <a>householderReflectionInplaceR</a>, but works from right
--   to left - use to zero elements to the right from the pivot.
--   
--   Returns <tt>True</tt> if reflection has been performed, and
--   <tt>False</tt> if it was not needed. This can be used to track the
--   sign of <tt>det P</tt>.
householderReflectionInplaceR :: forall (s :: Type) (t :: Type) (n :: Nat) (m :: Nat). (PrimBytes t, Ord t, Epsilon t, KnownDim n, KnownDim m) => STDataFrame s t '[m] -> STDataFrame s t '[m, m] -> STDataFrame s t '[n, m] -> Idxs '[n, m] -> ST s Bool

-- | Run a Householder transformation inplace.
--   
--   Given some orthongonal matrix &lt;math&gt;, some matrix &lt;math&gt;
--   and index &lt;math&gt;, reflects &lt;math&gt; along some hyperplane,
--   such that all elements of &lt;math&gt; below index &lt;math&gt; become
--   zeros, then updates &lt;math&gt; with the inverse of the same
--   transform as &lt;math&gt;.
--   
--   Notes and invariants:
--   
--   <ol>
--   <li>The transformation happens inplace for both matrices &lt;math&gt;
--   and &lt;math&gt;; if &lt;math&gt;, then &lt;math&gt;, where
--   &lt;math&gt; and &lt;math&gt; are the updated versions of the input
--   matrices, &lt;math&gt; and &lt;math&gt; are implicit matrices.</li>
--   <li>All elements below and to the left of index &lt;math&gt; in
--   &lt;math&gt; are assumed (and not checked) to be zeros; these are not
--   touched by the subroutine to save flops.</li>
--   <li>A logical starting value for &lt;math&gt; is an identity matrix.
--   The subroutine can be used for a QR decomposition: &lt;math&gt;.</li>
--   </ol>
--   
--   Returns <tt>True</tt> if reflection has been performed, and
--   <tt>False</tt> if it was not needed. This can be used to track the
--   sign of <tt>det P</tt>.
householderReflectionInplaceL :: forall (s :: Type) (t :: Type) (n :: Nat) (m :: Nat). (PrimBytes t, Ord t, Epsilon t, KnownDim n, KnownDim m) => STDataFrame s t '[n] -> STDataFrame s t '[n, n] -> STDataFrame s t '[n, m] -> Idxs '[n, m] -> ST s Bool


-- | A few ways to solve a system of linear equations in ST monad. The
--   tesult is always computed inplace.
module Numeric.Subroutine.SolveTriangular

-- | Solve a system of linear equations &lt;math&gt; or a linear least
--   squares problem &lt;math&gt;, where &lt;math&gt; is an
--   upper-triangular matrix.
--   
--   DataFrame &lt;math&gt; is modified in-place; by the end of the process
--   &lt;math&gt;.
--   
--   NB: you can use <a>subDataFrameView</a> to truncate <tt>b</tt> without
--   performing a copy.
solveUpperTriangularR :: forall (s :: Type) (t :: Type) (n :: Nat) (m :: Nat) (ds :: [Nat]). (PrimBytes t, Fractional t, Eq t, KnownDim m, m <= n) => DataFrame t '[n, m] -> STDataFrame s t (m :+ ds) -> ST s ()

-- | Solve a system of linear equations &lt;math&gt;, where &lt;math&gt; is
--   an upper-triangular matrix.
--   
--   DataFrame &lt;math&gt; is modified in-place; by the end of the process
--   &lt;math&gt;. The &lt;math&gt; rows of &lt;math&gt; are not used. Pad
--   each dimension of &lt;math&gt; with &lt;math&gt; zeros if you want to
--   get the full solution.
solveUpperTriangularL :: forall (s :: Type) (t :: Type) (n :: Nat) (m :: Nat) (ds :: [Nat]). (PrimBytes t, Fractional t, Eq t, KnownDim m, m <= n) => STDataFrame s t (ds +: m) -> DataFrame t '[n, m] -> ST s ()

-- | Solve a system of linear equations &lt;math&gt;, where &lt;math&gt; is
--   a lower-triangular matrix.
--   
--   DataFrame &lt;math&gt; is modified in-place; by the end of the process
--   &lt;math&gt;. The &lt;math&gt; columns of &lt;math&gt; are not used.
--   Pad &lt;math&gt; with &lt;math&gt; zero elements if you want to get
--   the full solution.
solveLowerTriangularR :: forall (s :: Type) (t :: Type) (n :: Nat) (m :: Nat) (ds :: [Nat]). (PrimBytes t, Fractional t, Eq t, KnownDim n, KnownDim m, n <= m) => DataFrame t '[n, m] -> STDataFrame s t (n :+ ds) -> ST s ()

-- | Solve a system of linear equations &lt;math&gt; or a linear least
--   squares problem &lt;math&gt;, where &lt;math&gt; is a lower-triangular
--   matrix.
--   
--   DataFrame &lt;math&gt; is modified in-place; by the end of the process
--   &lt;math&gt;. The last &lt;math&gt; columns of &lt;math&gt; and
--   &lt;math&gt; and are not touched.
solveLowerTriangularL :: forall (s :: Type) (t :: Type) (n :: Nat) (m :: Nat) (ds :: [Nat]). (PrimBytes t, Fractional t, Eq t, KnownDim n, KnownDim m, n <= m) => STDataFrame s t (ds +: m) -> DataFrame t '[n, m] -> ST s ()

module Numeric.Subroutine.Sort
class BoundedDim n => SortBy n

-- | Note, <a>Inplace</a> here means the input frame is modified. It does
--   not mean the algorithm does not use extra space (it does use).
sortByInplace :: (SortBy n, PrimBytes t) => (STDataFrame s t ns -> STDataFrame s t ns -> ST s Ordering) -> STDataFrame s t (n : ns) -> ST s ()

-- | Sort a <tt>DataFrame</tt> along the first dimension using given
--   comparison function.
sortBy :: forall (t :: Type) n ns. (SortableDataFrame t (n : ns), SortBy n) => (DataFrame t ns -> DataFrame t ns -> Ordering) -> DataFrame t (n : ns) -> DataFrame t (n : ns)

-- | Sort a <tt>DataFrame</tt> along the first dimension.
--   
--   Note: the elements (which are of type <tt>DataFrame t ns</tt>) are
--   compared lexicographically.
sort :: forall (t :: Type) n ns. (SortableDataFrame t (n : ns), Ord t, SortBy n) => DataFrame t (n : ns) -> DataFrame t (n : ns)

-- | The required context for sorting a DataFrame is slightly different for
--   <tt>Nat</tt> and <tt>XNat</tt> indexed arrays. This type family
--   abstracts away the difference.
type family SortableDataFrame (t :: Type) (ns :: [k]) :: Constraint
instance Numeric.Subroutine.Sort.SortBy 0
instance Numeric.Subroutine.Sort.SortBy 1
instance Numeric.Subroutine.Sort.SortBy 2
instance Numeric.Subroutine.Sort.SortBy 3
instance Numeric.Subroutine.Sort.SortBy 4
instance Numeric.Dimensions.Dim.KnownDim n => Numeric.Subroutine.Sort.SortBy n
instance Numeric.Dimensions.Dim.BoundedDim xn => Numeric.Subroutine.Sort.SortBy xn


-- | Vector is an alias to a DataFrame with order 1.
module Numeric.Vector
type Vector (t :: l) (n :: k) = DataFrame t '[n]
type Vec2f = Vector Float 2
type Vec3f = Vector Float 3
type Vec4f = Vector Float 4
type Vec2d = Vector Double 2
type Vec3d = Vector Double 3
type Vec4d = Vector Double 4
type Vec2i = Vector Int 2
type Vec3i = Vector Int 3
type Vec4i = Vector Int 4
type Vec2w = Vector Word 2
type Vec3w = Vector Word 3
type Vec4w = Vector Word 4

-- | Packing and unpacking 2D vectors
class Vector2 t

-- | Compose a 2D vector
vec2 :: Vector2 t => t -> t -> Vector t 2

-- | Unpack 2D vector elements
unpackV2# :: Vector2 t => Vector t 2 -> (# t, t #)

-- | Packing and unpacking 3D vectors
class Vector3 t

-- | Compose a 3D vector
vec3 :: Vector3 t => t -> t -> t -> Vector t 3

-- | Unpack 3D vector elements
unpackV3# :: Vector3 t => Vector t 3 -> (# t, t, t #)

-- | Packing and unpacking 4D vectors
class Vector4 t

-- | Compose a 4D vector
vec4 :: Vector4 t => t -> t -> t -> t -> Vector t 4

-- | Unpack 4D vector elements
unpackV4# :: Vector4 t => Vector t 4 -> (# t, t, t, t #)

-- | Keep data in a primitive data frame and maintain information about
--   Dimensions in the type system
data family DataFrame (t :: l) (xs :: [k])
pattern Vec2 :: Vector2 t => t -> t -> Vector t 2
pattern Vec3 :: Vector3 t => t -> t -> t -> Vector t 3
pattern Vec4 :: Vector4 t => t -> t -> t -> t -> Vector t 4

-- | Scalar product -- sum of Vecs' components products, propagated into
--   whole Vec
(.*.) :: (Num t, Num (Vector t n), SubSpace t '[n] '[] '[n]) => Vector t (n :: Nat) -> Vector t n -> Vector t n
infixl 7 .*.

-- | Scalar product -- sum of Vecs' components products -- a scalar
dot :: (Num t, Num (Vector t n), SubSpace t '[n] '[] '[n]) => Vector t (n :: Nat) -> Vector t n -> Scalar t

-- | Dot product of two vectors
(·) :: (Num t, Num (Vector t n), SubSpace t '[n] '[] '[n]) => Vector t (n :: Nat) -> Vector t n -> Scalar t
infixl 7 ·

-- | Sum of absolute values
normL1 :: (Num (DataFrame t ('[] :: [k])), SubSpace t '[n] '[] '[n]) => Vector t (n :: k) -> DataFrame t ('[] :: [k])

-- | hypot function (square root of squares)
normL2 :: (Floating (DataFrame t ('[] :: [k])), SubSpace t '[n] '[] '[n]) => Vector t (n :: k) -> DataFrame t ('[] :: [k])

-- | Maximum of absolute values
normLPInf :: (Ord (DataFrame t ('[] :: [k])), Num (DataFrame t ('[] :: [k])), SubSpace t '[n] '[] '[n]) => Vector t (n :: k) -> DataFrame t ('[] :: [k])

-- | Minimum of absolute values
normLNInf :: (Ord (DataFrame t ('[] :: [k])), Num (DataFrame t ('[] :: [k])), SubSpace t '[n] '[] '[n]) => Vector t (n :: k) -> DataFrame t ('[] :: [k])

-- | Norm in Lp space
normLP :: (Floating (DataFrame t ('[] :: [k])), SubSpace t '[n] '[] '[n]) => Int -> Vector t (n :: k) -> DataFrame t ('[] :: [k])

-- | Normalize vector w.r.t. Euclidean metric (L2).
normalized :: forall (k :: Type) (t :: Type) (n :: k). (Floating (DataFrame t ('[] :: [k])), SubSpace t '[n] '[] '[n]) => Vector t n -> Vector t n

-- | Take a determinant of a matrix composed from two 2D vectors. Like a
--   cross product in 2D.
det2 :: (Num t, PrimBytes t) => Vector t 2 -> Vector t 2 -> Scalar t

-- | Cross product
cross :: (Num t, PrimBytes t) => Vector t 3 -> Vector t 3 -> Vector t 3

-- | Cross product for two vectors in 3D
(×) :: (Num t, SubSpace t '[3] '[] '[3]) => Vector t 3 -> Vector t 3 -> Vector t 3
infixl 7 ×


-- | Quaternion operations implemented for Floats and Doubles.
--   
--   The types <a>QDouble</a> and <a>QFloat</a> have the same
--   representation as corresponding <tt>Vector t 4</tt>. This means, you
--   can do a cheap conversion between the types.
--   
--   However, arithmetic instances, such as Num and Floating are
--   implemented in substentially different ways. For example, fromInteger
--   fills a vector fully but sets only real part to a quaternion:
--   
--   <pre>
--   &gt;&gt;&gt; 1 = vec4 1 1 1 1
--   
--   &gt;&gt;&gt; 1 = packQ 0 0 0 1
--   </pre>
--   
--   All other numeric operations for vectors are element-wise, but for
--   quaternions I have implemented the actual quaternion math. In most of
--   the cases, you can think of these as being operations on complex
--   numbers, where the role of imaginary <tt>i</tt> is played by a 3D
--   vector. Some of the operations are ambiguous for quaternions; for
--   example &lt;math&gt;, but also &lt;math&gt;, and &lt;math&gt;, and any
--   other unit quaterion with zero real part. In cases like this, I stick
--   to the <tt>i</tt>-th axis: &lt;math&gt;
module Numeric.Quaternion

-- | Quaternion operations
class (Floating (Quater t), Floating t, Ord t, PrimBytes t, KnownBackend t '[3], KnownBackend t '[4], KnownBackend t '[3, 3], KnownBackend t '[4, 4]) => Quaternion t where {
    
    -- | Quaternion data type. The ordering of coordinates is
    --   <tt>(x,y,z,w)</tt>, where <tt>w</tt> is the argument, and <tt>x y
    --   z</tt> are the components of a 3D vector
    data family Quater t;
}

-- | Set the quaternion in format <tt>(x,y,z,w)</tt>
packQ :: Quaternion t => t -> t -> t -> t -> Quater t

-- | Get the values of the quaternion in format <tt>(x,y,z,w)</tt>
unpackQ# :: Quaternion t => Quater t -> (# t, t, t, t #)

-- | Set the quaternion from 3D axis vector and argument
fromVecNum :: Quaternion t => Vector t 3 -> t -> Quater t

-- | Set the quaternion from 4D vector in format <tt>(x,y,z,w)</tt>
fromVec4 :: Quaternion t => Vector t 4 -> Quater t

-- | Transform the quaternion to 4D vector in format <tt>(x,y,z,w)</tt>
toVec4 :: Quaternion t => Quater t -> Vector t 4

-- | Get scalar square of the quaternion.
--   
--   <pre>
--   &gt;&gt;&gt; realToFrac (square q) == q * conjugate q
--   </pre>
square :: Quaternion t => Quater t -> t

-- | Imaginary part of the quaternion (orientation vector)
im :: Quaternion t => Quater t -> Quater t

-- | Real part of the quaternion
re :: Quaternion t => Quater t -> Quater t

-- | Imaginary part of the quaternion as a 3D vector
imVec :: Quaternion t => Quater t -> Vector t 3

-- | Real part of the quaternion as a scalar
taker :: Quaternion t => Quater t -> t

-- | i-th component
takei :: Quaternion t => Quater t -> t

-- | j-th component
takej :: Quaternion t => Quater t -> t

-- | k-th component
takek :: Quaternion t => Quater t -> t

-- | Conjugate quaternion (negate imaginary part)
conjugate :: Quaternion t => Quater t -> Quater t

-- | Rotates and scales vector in 3D using quaternion. Let &lt;math&gt; ,
--   &lt;math&gt;, &lt;math&gt;; then the rotation angle is &lt;math&gt;,
--   and the axis of rotation is &lt;math&gt;. Scaling is proportional to
--   &lt;math&gt;.
--   
--   <pre>
--   &gt;&gt;&gt; rotScale q x == q * x * (conjugate q)
--   </pre>
rotScale :: Quaternion t => Quater t -> Vector t 3 -> Vector t 3

-- | Creates a quaternion <tt>q</tt> from two vectors <tt>a</tt> and
--   <tt>b</tt>, such that <tt>rotScale q a == b</tt>.
getRotScale :: Quaternion t => Vector t 3 -> Vector t 3 -> Quater t

-- | Creates a rotation versor from an axis vector and an angle in radians.
--   Result is always a unit quaternion (versor). If the argument vector is
--   zero, then result is a real unit quaternion.
axisRotation :: Quaternion t => Vector t 3 -> t -> Quater t

-- | Quaternion rotation angle &lt;math&gt; (where &lt;math&gt; ,
--   &lt;math&gt;, &lt;math&gt;).
--   
--   <pre>
--   &gt;&gt;&gt; q /= 0 ==&gt; axisRotation (imVec q) (qArg q) == signum q
--   </pre>
qArg :: Quaternion t => Quater t -> t

-- | Create a quaternion from a rotation matrix. Note, that rotations of
--   &lt;math&gt; and &lt;math&gt; are equivalent, there result of this
--   function may be ambiguious. Assume the sign of the result to be chosen
--   arbitrarily.
fromMatrix33 :: Quaternion t => Matrix t 3 3 -> Quater t

-- | Create a quaternion from a homogenious coordinates trasform matrix.
--   Ignores matrix translation transform. Note, that rotations of
--   &lt;math&gt; and &lt;math&gt; are equivalent, there result of this
--   function may be ambiguious. Assume the sign of the result to be chosen
--   arbitrarily.
fromMatrix44 :: Quaternion t => Matrix t 4 4 -> Quater t

-- | Create a rotation matrix from a quaternion. Note, that rotations of
--   &lt;math&gt; and &lt;math&gt; are equivalent, so the following
--   property holds:
--   
--   <pre>
--   &gt;&gt;&gt; toMatrix33 q == toMatrix33 (-q)
--   </pre>
toMatrix33 :: Quaternion t => Quater t -> Matrix t 3 3

-- | Create a homogenious coordinates trasform matrix from a quaternion.
--   Translation of the output matrix is zero. Note, that rotations of
--   &lt;math&gt; and &lt;math&gt; are equivalent, so the following
--   property holds:
--   
--   <pre>
--   &gt;&gt;&gt; toMatrix44 q == toMatrix44 (-q)
--   </pre>
toMatrix44 :: Quaternion t => Quater t -> Matrix t 4 4
type QDouble = Quater Double
type QFloat = Quater Float

module Numeric.Matrix.QR

-- | Result of QR factorization &lt;math&gt;.
data QR (t :: Type) (n :: Nat) (m :: Nat)
QR :: Matrix t n n -> Scalar t -> Matrix t n m -> QR

-- | Orthogonal matrix &lt;math&gt;
[qrQ] :: QR -> Matrix t n n

-- | A shortcut for evaluating a determinant of &lt;math&gt;
[qrQDet] :: QR -> Scalar t

-- | Upper-triangular matrix &lt;math&gt;
[qrR] :: QR -> Matrix t n m

-- | Result of LQ factorization &lt;math&gt;.
data LQ (t :: Type) (n :: Nat) (m :: Nat)
LQ :: Matrix t n m -> Matrix t m m -> Scalar t -> LQ

-- | Lower-triangular matrix &lt;math&gt;
[lqL] :: LQ -> Matrix t n m

-- | Orthogonal matrix &lt;math&gt;
[lqQ] :: LQ -> Matrix t m m

-- | A shortcut for evaluating a determinant of &lt;math&gt;
[lqQDet] :: LQ -> Scalar t
class (PrimBytes t, Ord t, Epsilon t, KnownDim n, KnownDim m) => MatrixQR t (n :: Nat) (m :: Nat)

-- | Compute QR factorization
qr :: MatrixQR t n m => Matrix t n m -> QR t n m

-- | Compute LQ factorization
lq :: MatrixQR t n m => Matrix t n m -> LQ t n m

-- | Calculate determinant of a matrix via QR decomposition
detViaQR :: forall t n. MatrixQR t n n => Matrix t n n -> Scalar t

-- | Calculate inverse of a matrix via QR decomposition
inverseViaQR :: forall t n. MatrixQR t n n => Matrix t n n -> Matrix t n n

-- | Compute a QR or LQ decomposition of matrix &lt;math&gt;, and solve a
--   system of linear equations &lt;math&gt;.
--   
--   If &lt;math&gt; QR decomposition is used; if &lt;math&gt; this
--   function solves linear least squares problem. If &lt;math&gt;
--   (underdetermined system) LQ decomposition is used to yield a minimum
--   norm solution.
qrSolveR :: forall t (n :: Nat) (m :: Nat) (ds :: [Nat]). (MatrixQR t n m, Dimensions ds) => Matrix t n m -> DataFrame t (n :+ ds) -> DataFrame t (m :+ ds)

-- | Compute a QR or LQ decomposition of matrix &lt;math&gt;, and solve a
--   system of linear equations &lt;math&gt;.
--   
--   If &lt;math&gt; LQ decomposition is used; if &lt;math&gt; this
--   function solves linear least squares problem. If &lt;math&gt;
--   (underdetermined system) QR decomposition is used to yield a minimum
--   norm solution.
qrSolveL :: forall t (n :: Nat) (m :: Nat) (ds :: [Nat]). (MatrixQR t n m, Dimensions ds) => Matrix t n m -> DataFrame t (ds +: m) -> DataFrame t (ds +: n)
instance (GHC.Classes.Eq t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m) => GHC.Classes.Eq (Numeric.Matrix.QR.QR t n m)
instance (GHC.Show.Show t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m) => GHC.Show.Show (Numeric.Matrix.QR.QR t n m)
instance (GHC.Classes.Eq t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m) => GHC.Classes.Eq (Numeric.Matrix.QR.LQ t n m)
instance (GHC.Show.Show t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m) => GHC.Show.Show (Numeric.Matrix.QR.LQ t n m)
instance (Numeric.PrimBytes.PrimBytes t, GHC.Classes.Ord t, Numeric.Basics.Epsilon t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m) => Numeric.Matrix.QR.MatrixQR t n m

module Numeric.Matrix.LU
class (KnownDim n, Ord t, Fractional t, PrimBytes t, KnownBackend t '[n, n]) => MatrixLU t (n :: Nat)

-- | Compute LU factorization with Partial Pivoting
lu :: MatrixLU t n => Matrix t n n -> LU t n

-- | Result of LU factorization with Partial Pivoting &lt;math&gt;.
data LU (t :: Type) (n :: Nat)
LU :: Matrix t n n -> Matrix t n n -> Matrix t n n -> Scalar t -> LU

-- | Unit lower triangular matrix &lt;math&gt;. All elements on the
--   diagonal of <tt>L</tt> equal <tt>1</tt>. The rest of the elements
--   satisfy &lt;math&gt;.
[luLower] :: LU -> Matrix t n n

-- | Upper triangular matrix &lt;math&gt;
[luUpper] :: LU -> Matrix t n n

-- | Row permutation matrix &lt;math&gt;
[luPerm] :: LU -> Matrix t n n

-- | Sign of permutation <tt>luPermDet == det . luPerm</tt>; &lt;math&gt;.
[luPermDet] :: LU -> Scalar t

-- | Solve <tt>Ax = b</tt> problem given LU decomposition of A.
luSolveR :: forall t (n :: Nat) (ds :: [Nat]). (MatrixLU t n, Dimensions ds) => LU t n -> DataFrame t (n :+ ds) -> DataFrame t (n :+ ds)

-- | Solve <tt>xA = b</tt> problem given LU decomposition of A.
luSolveL :: forall t (n :: Nat) (ds :: [Nat]). (MatrixLU t n, Dimensions ds) => LU t n -> DataFrame t (ds +: n) -> DataFrame t (ds +: n)

-- | Calculate determinant of a matrix via LU decomposition
detViaLU :: forall (t :: Type) (n :: Nat). MatrixLU t n => Matrix t n n -> Scalar t

-- | Calculate inverse of a matrix via LU decomposition
inverseViaLU :: forall (t :: Type) (n :: Nat). MatrixLU t n => Matrix t n n -> Matrix t n n
instance (GHC.Show.Show t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.KnownDim n) => GHC.Show.Show (Numeric.Matrix.LU.LU t n)
instance (GHC.Classes.Eq (Numeric.Matrix.Internal.Matrix t n n), GHC.Classes.Eq t) => GHC.Classes.Eq (Numeric.Matrix.LU.LU t n)
instance (Numeric.Dimensions.Dim.KnownDim n, GHC.Classes.Ord t, GHC.Real.Fractional t, Numeric.PrimBytes.PrimBytes t, Numeric.DataFrame.Internal.Backend.KnownBackend t '[n, n]) => Numeric.Matrix.LU.MatrixLU t n

module Numeric.Matrix
class MatrixTranspose t (n :: k) (m :: k)

-- | Transpose Mat
transpose :: MatrixTranspose t n m => Matrix t n m -> Matrix t m n
class SquareMatrix t (n :: Nat)

-- | Mat with 1 on diagonal and 0 elsewhere
eye :: SquareMatrix t n => Matrix t n n

-- | Put the same value on the Mat diagonal, 0 otherwise
diag :: SquareMatrix t n => Scalar t -> Matrix t n n

-- | Sum of diagonal elements
trace :: SquareMatrix t n => Matrix t n n -> Scalar t
class MatrixDeterminant t (n :: Nat)

-- | Determinant of Mat
det :: MatrixDeterminant t n => Matrix t n n -> Scalar t
class MatrixInverse t (n :: Nat)

-- | Matrix inverse
inverse :: MatrixInverse t n => Matrix t n n -> Matrix t n n

-- | Alias for DataFrames of rank 2
type Matrix (t :: l) (n :: k) (m :: k) = DataFrame t '[n, m]

-- | Operations on 4x4 transformation matrices and vectors in homogeneous
--   coordinates. All angles are specified in radians.
--   
--   Note: since version 2 of <tt>easytensor</tt>, DataFrames and matrices
--   are row-major. A good SIMD implementation may drastically improve
--   performance of 4D vector-matrix products of the form <tt>v %* m</tt>,
--   but not so much for products of the form <tt>m %* v</tt> (due to
--   memory layout). Thus, all operations here assume the former form to
--   benefit more from SIMD in future.
class HomTransform4 t

-- | Create a translation matrix from a vector. The 4th coordinate is
--   ignored.
--   
--   If <tt>p ! 3 == 1</tt> and <tt>v ! 3 == 0</tt>, then
--   
--   <pre>
--   p %* translate4 v == p + v
--   </pre>
translate4 :: HomTransform4 t => Vector t 4 -> Matrix t 4 4

-- | Create a translation matrix from a vector.
--   
--   If <tt>p ! 3 == 1</tt>, then
--   
--   <pre>
--   p %* translate3 v == p + toHomVector v
--   </pre>
translate3 :: HomTransform4 t => Vector t 3 -> Matrix t 4 4

-- | Rotation matrix for a rotation around the X axis, angle is given in
--   radians. e.g. <tt>p %* rotateX (pi/2)</tt> rotates point <tt>p</tt>
--   around <tt>Ox</tt> by 90 degrees.
rotateX :: HomTransform4 t => t -> Matrix t 4 4

-- | Rotation matrix for a rotation around the Y axis, angle is given in
--   radians. e.g. <tt>p %* rotateY (pi/2)</tt> rotates point <tt>p</tt>
--   around <tt>Oy</tt> by 90 degrees.
rotateY :: HomTransform4 t => t -> Matrix t 4 4

-- | Rotation matrix for a rotation around the Z axis, angle is given in
--   radians. e.g. <tt>p %* rotateZ (pi/2)</tt> rotates point <tt>p</tt>
--   around <tt>Oz</tt> by 90 degrees.
rotateZ :: HomTransform4 t => t -> Matrix t 4 4

-- | Rotation matrix for a rotation around an arbitrary normalized vector
--   e.g. <tt>p %* rotate (pi/2) v</tt> rotates point <tt>p</tt> around
--   <tt>v</tt> by 90 degrees.
rotate :: HomTransform4 t => Vector t 3 -> t -> Matrix t 4 4

-- | Rotation matrix from the Euler angles roll (axis <tt>Z</tt>), yaw
--   (axis <tt>Y'</tt>), and pitch (axis <tt>X''</tt>). This order is known
--   as Tait-Bryan angles (<tt>Z-Y'-X''</tt> intrinsic rotations), or
--   nautical angles, or Cardan angles.
--   
--   <pre>
--   rotateEuler pitch yaw roll == rotateZ roll %* rotateY yaw %* rotateX pitch
--   </pre>
--   
--   <a>https://en.wikipedia.org/wiki/Euler_angles#Conventions_2</a>
rotateEuler :: HomTransform4 t => t -> t -> t -> Matrix t 4 4

-- | Create a transform matrix using up direction, camera position and a
--   point to look at. Just the same as GluLookAt.
lookAt :: HomTransform4 t => Vector t 3 -> Vector t 3 -> Vector t 3 -> Matrix t 4 4

-- | A perspective symmetric projection matrix. Right-handed coordinate
--   system. (<tt>x</tt> - right, <tt>y</tt> - top)
--   <a>http://en.wikibooks.org/wiki/GLSL_Programming/Vertex_Transformations</a>
perspective :: HomTransform4 t => t -> t -> t -> t -> Matrix t 4 4

-- | An orthogonal symmetric projection matrix. Right-handed coordinate
--   system. (<tt>x</tt> - right, <tt>y</tt> - top)
--   <a>http://en.wikibooks.org/wiki/GLSL_Programming/Vertex_Transformations</a>
orthogonal :: HomTransform4 t => t -> t -> t -> t -> Matrix t 4 4

-- | Add one more dimension and set it to 1.
toHomPoint :: HomTransform4 t => Vector t 3 -> Vector t 4

-- | Add one more dimension and set it to 0.
toHomVector :: HomTransform4 t => Vector t 3 -> Vector t 4

-- | Transform a homogenous vector or point into a normal 3D vector. If the
--   last coordinate is not zero, divide the rest by it.
fromHom :: HomTransform4 t => Vector t 4 -> Vector t 3
type Mat22f = Matrix Float 2 2
type Mat23f = Matrix Float 2 3
type Mat24f = Matrix Float 2 4
type Mat32f = Matrix Float 3 2
type Mat33f = Matrix Float 3 3
type Mat34f = Matrix Float 3 4
type Mat42f = Matrix Float 4 2
type Mat43f = Matrix Float 4 3
type Mat44f = Matrix Float 4 4
type Mat22d = Matrix Double 2 2
type Mat23d = Matrix Double 2 3
type Mat24d = Matrix Double 2 4
type Mat32d = Matrix Double 3 2
type Mat33d = Matrix Double 3 3
type Mat34d = Matrix Double 3 4
type Mat42d = Matrix Double 4 2
type Mat43d = Matrix Double 4 3
type Mat44d = Matrix Double 4 4

-- | Compose a 2x2D matrix
mat22 :: PrimBytes (t :: Type) => Vector t 2 -> Vector t 2 -> Matrix t 2 2

-- | Compose a 3x3D matrix
mat33 :: PrimBytes (t :: Type) => Vector t 3 -> Vector t 3 -> Vector t 3 -> Matrix t 3 3

-- | Compose a 4x4D matrix
mat44 :: PrimBytes (t :: Type) => Vector t 4 -> Vector t 4 -> Vector t 4 -> Vector t 4 -> Matrix t 4 4

-- | Tensor contraction. In particular: 1. matrix-matrix product 2.
--   matrix-vector or vector-matrix product 3. dot product of two vectors.
(%*) :: (Contraction t as bs asbs, KnownDim m, PrimArray t (DataFrame t (as +: m)), PrimArray t (DataFrame t (m :+ bs)), PrimArray t (DataFrame t asbs)) => DataFrame t (as +: m) -> DataFrame t (m :+ bs) -> DataFrame t asbs
infixl 7 %*

module Numeric.DataFrame

-- | Sort a <tt>DataFrame</tt> along the first dimension.
--   
--   Note: the elements (which are of type <tt>DataFrame t ns</tt>) are
--   compared lexicographically.
sort :: forall (t :: Type) n ns. (SortableDataFrame t (n : ns), Ord t, SortBy n) => DataFrame t (n : ns) -> DataFrame t (n : ns)

-- | Sort a <tt>DataFrame</tt> along the first dimension using given
--   comparison function.
sortBy :: forall (t :: Type) n ns. (SortableDataFrame t (n : ns), SortBy n) => (DataFrame t ns -> DataFrame t ns -> Ordering) -> DataFrame t (n : ns) -> DataFrame t (n : ns)

module Numeric.Matrix.Bidiagonal

-- | Decomposition of a matrix &lt;math&gt; such that &lt;math&gt; and
--   &lt;math&gt; are orthogonal and &lt;math&gt; is bidiagonal.
data BiDiag (t :: Type) (n :: Nat) (m :: Nat)
BiDiag :: Matrix t n n -> Scalar t -> Vector t (Min n m) -> Vector t (Min n m) -> Matrix t m m -> Scalar t -> BiDiag

-- | &lt;math&gt; left orthogonal matrix
[bdU] :: BiDiag -> Matrix t n n

-- | A shortcut for evaluating a determinant of &lt;math&gt;
[bdUDet] :: BiDiag -> Scalar t

-- | Main diagonal of &lt;math&gt;
[bdAlpha] :: BiDiag -> Vector t (Min n m)

-- | First upper diagonal of &lt;math&gt;; its last element equals zero if
--   &lt;math&gt;
[bdBeta] :: BiDiag -> Vector t (Min n m)

-- | &lt;math&gt; left orthogonal matrix
[bdV] :: BiDiag -> Matrix t m m

-- | A shortcut for evaluating a determinant of &lt;math&gt;
[bdVDet] :: BiDiag -> Scalar t

-- | Put two vectors on the main and first upper diagonal.
biDiag :: forall (t :: Type) (n :: Nat) (m :: Nat). (PrimBytes t, Num t) => Dims '[n, m] -> Vector t (Min n m) -> Vector t (Min n m) -> Matrix t n m

-- | Decompose a matrix &lt;math&gt; such that ( U ) and &lt;math&gt; are
--   orthogonal and &lt;math&gt; is bidiagonal.
--   
--   The first returned number
bidiagonalHouseholder :: forall (t :: Type) (n :: Nat) (m :: Nat). (PrimBytes t, Ord t, Epsilon t, KnownDim n, KnownDim m) => Matrix t n m -> BiDiag t n m
instance (GHC.Show.Show t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m, Numeric.Dimensions.Dim.KnownDim (Data.Type.Lits.Min n m)) => GHC.Show.Show (Numeric.Matrix.Bidiagonal.BiDiag t n m)
instance (GHC.Classes.Eq t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m, Numeric.Dimensions.Dim.KnownDim (Data.Type.Lits.Min n m), Numeric.DataFrame.Internal.Backend.KnownBackend t '[Data.Type.Lits.Min n m]) => GHC.Classes.Eq (Numeric.Matrix.Bidiagonal.BiDiag t n m)

module Numeric.Matrix.SVD
class RealFloatExtras t => MatrixSVD (t :: Type) (n :: Nat) (m :: Nat)

-- | Compute SVD factorization of a matrix
svd :: (MatrixSVD t n m, IterativeMethod) => Matrix t n m -> SVD t n m

-- | Result of SVD factorization <tt> M = svdU %* asDiag svdS %* transpose
--   svdV </tt>.
--   
--   Invariants:
--   
--   <ul>
--   <li>Singular values <a>svdS</a> are in non-increasing order and are
--   non-negative.</li>
--   <li>svdU and svdV are orthogonal matrices</li>
--   <li>det svdU == 1</li>
--   </ul>
--   
--   NB: <a>SVD on wiki</a>
data SVD (t :: Type) (n :: Nat) (m :: Nat)
SVD :: Matrix t n n -> Vector t (Min n m) -> Matrix t m m -> SVD

-- | Left-singular basis matrix
[svdU] :: SVD -> Matrix t n n

-- | Vector of singular values
[svdS] :: SVD -> Vector t (Min n m)

-- | Right-singular basis matrix
[svdV] :: SVD -> Matrix t m m

-- | Obvious dummy implementation of SVD for 1x1 matrices
svd1 :: (PrimBytes t, Num t, Eq t) => Matrix t 1 1 -> SVD t 1 1

-- | SVD of a 2x2 matrix can be computed analytically
--   
--   Related discussion:
--   
--   
--   <a>https://scicomp.stackexchange.com/questions/8899/robust-algorithm-for-2-times-2-svd/</a>
--   
--   <a>https://ieeexplore.ieee.org/document/486688</a>
svd2 :: forall t. RealFloatExtras t => Matrix t 2 2 -> SVD t 2 2

-- | Get SVD decomposition of a 3x3 matrix using <a>svd3q</a> function.
--   
--   This function reorders the singular components under the hood to make
--   sure <tt>s1 &gt;= s2 &gt;= s3 &gt;= 0</tt>. Thus, it has some overhead
--   on top of <a>svd3q</a>.
svd3 :: forall t. (Quaternion t, RealFloatExtras t) => Matrix t 3 3 -> SVD t 3 3

-- | Get SVD decomposition of a 3x3 matrix, with orthogonal matrices U and
--   V represented as quaternions. Important: U and V are bound to be
--   rotations at the expense of the last singular value being possibly
--   negative.
--   
--   This is an adoptation of a specialized 3x3 SVD algorithm described in
--   "Computing the Singular Value Decomposition of 3x3 matrices with
--   minimal branching and elementary floating point operations", by A.
--   McAdams, A. Selle, R. Tamstorf, J. Teran, E. Sifakis.
--   
--   <a>http://pages.cs.wisc.edu/~sifakis/papers/SVD_TR1690.pdf</a>
svd3q :: forall t. (Quaternion t, RealFloatExtras t) => Matrix t 3 3 -> (Quater t, Vector t 3, Quater t)
instance (GHC.Show.Show t, Numeric.PrimBytes.PrimBytes t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m, Numeric.Dimensions.Dim.KnownDim (Data.Type.Lits.Min n m)) => GHC.Show.Show (Numeric.Matrix.SVD.SVD t n m)
instance (GHC.Classes.Eq (Numeric.Matrix.Internal.Matrix t n n), GHC.Classes.Eq (Numeric.Matrix.Internal.Matrix t m m), GHC.Classes.Eq (Numeric.Vector.Internal.Vector t (Data.Type.Lits.Min n m))) => GHC.Classes.Eq (Numeric.Matrix.SVD.SVD t n m)
instance Numeric.Basics.RealFloatExtras t => Numeric.Matrix.SVD.MatrixSVD t 1 1
instance Numeric.Basics.RealFloatExtras t => Numeric.Matrix.SVD.MatrixSVD t 2 2
instance (Numeric.Basics.RealFloatExtras t, Numeric.Quaternion.Internal.Quaternion t) => Numeric.Matrix.SVD.MatrixSVD t 3 3
instance (Numeric.Basics.RealFloatExtras t, Numeric.Dimensions.Dim.KnownDim n, Numeric.Dimensions.Dim.KnownDim m) => Numeric.Matrix.SVD.MatrixSVD t n m