GenIMatrix.hs

{-# OPTIONS_GHC -Wall #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# Language ForeignFunctionInterface #-}
{-# Language FlexibleInstances #-}
{-# Language MultiParamTypeClasses #-}

module Casadi.Wrappers.Classes.GenIMatrix
       (
         GenIMatrix,
         GenIMatrixClass(..),
         genIMatrix_dimString,
         genIMatrix_isDense,
         genIMatrix_isEmpty,
         genIMatrix_isEmpty',
         genIMatrix_isScalar,
         genIMatrix_isScalar',
         genIMatrix_isSquare,
         genIMatrix_isTril,
         genIMatrix_isTriu,
         genIMatrix_isVector,
         genIMatrix_mul_smart,
         genIMatrix_numel,
         genIMatrix_ones,
         genIMatrix_ones',
         genIMatrix_ones'',
         genIMatrix_ones''',
         genIMatrix_size,
         genIMatrix_size',
         genIMatrix_size1,
         genIMatrix_size2,
         genIMatrix_sizeD,
         genIMatrix_sizeL,
         genIMatrix_sizeU,
         genIMatrix_sparse,
         genIMatrix_sparse',
         genIMatrix_sparse'',
         genIMatrix_sparsityRef,
         genIMatrix_sym,
         genIMatrix_sym',
         genIMatrix_sym'',
         genIMatrix_sym''',
         genIMatrix_sym'''',
         genIMatrix_sym''''',
         genIMatrix_sym'''''',
         genIMatrix_sym''''''',
         genIMatrix_zeros,
         genIMatrix_zeros',
         genIMatrix_zeros'',
         genIMatrix_zeros''',
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Ptr ( Ptr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Wrappers.CToolsInstances ( )
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, StdString' ) -- StdOstream'
import Casadi.Marshal ( Marshal(..), withMarshal )
import Casadi.WrapReturn ( WrapReturn(..) )

-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____size" c_CasADi__GenericMatrix_CasADi__Matrix_int____size
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____size
  :: GenIMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_int____size x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____size x0' >>= wrapReturn

-- classy wrapper
{-|
>>  int CasADi::GenericMatrix< MatType >::size() const 
>------------------------------------------------------------------------
>
>Get the number of (structural) non-zero elements.
>
>>  int CasADi::GenericMatrix< MatType >::size(SparsityType sp) const 
>------------------------------------------------------------------------
>
>Get the number if non-zeros for a given sparsity pattern.
-}
genIMatrix_size :: GenIMatrixClass a => a -> IO Int
genIMatrix_size x = casADi__GenericMatrix_CasADi__Matrix_int____size (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sizeL" c_CasADi__GenericMatrix_CasADi__Matrix_int____sizeL
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____sizeL
  :: GenIMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_int____sizeL x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sizeL x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of non-zeros in the lower triangular half.
-}
genIMatrix_sizeL :: GenIMatrixClass a => a -> IO Int
genIMatrix_sizeL x = casADi__GenericMatrix_CasADi__Matrix_int____sizeL (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sizeU" c_CasADi__GenericMatrix_CasADi__Matrix_int____sizeU
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____sizeU
  :: GenIMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_int____sizeU x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sizeU x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of non-zeros in the upper triangular half.
-}
genIMatrix_sizeU :: GenIMatrixClass a => a -> IO Int
genIMatrix_sizeU x = casADi__GenericMatrix_CasADi__Matrix_int____sizeU (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sizeD" c_CasADi__GenericMatrix_CasADi__Matrix_int____sizeD
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____sizeD
  :: GenIMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_int____sizeD x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sizeD x0' >>= wrapReturn

-- classy wrapper
{-|
>Get get the number of non-zeros on the diagonal.
-}
genIMatrix_sizeD :: GenIMatrixClass a => a -> IO Int
genIMatrix_sizeD x = casADi__GenericMatrix_CasADi__Matrix_int____sizeD (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____numel" c_CasADi__GenericMatrix_CasADi__Matrix_int____numel
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____numel
  :: GenIMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_int____numel x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____numel x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of elements.
-}
genIMatrix_numel :: GenIMatrixClass a => a -> IO Int
genIMatrix_numel x = casADi__GenericMatrix_CasADi__Matrix_int____numel (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____size1" c_CasADi__GenericMatrix_CasADi__Matrix_int____size1
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____size1
  :: GenIMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_int____size1 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____size1 x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the first dimension (i.e. number of rows)
-}
genIMatrix_size1 :: GenIMatrixClass a => a -> IO Int
genIMatrix_size1 x = casADi__GenericMatrix_CasADi__Matrix_int____size1 (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____size2" c_CasADi__GenericMatrix_CasADi__Matrix_int____size2
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____size2
  :: GenIMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_int____size2 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____size2 x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the second dimension (i.e. number of columns)
-}
genIMatrix_size2 :: GenIMatrixClass a => a -> IO Int
genIMatrix_size2 x = casADi__GenericMatrix_CasADi__Matrix_int____size2 (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____size_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____size_TIC
  :: Ptr GenIMatrix' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____size'
  :: GenIMatrix -> SparsityType -> IO Int
casADi__GenericMatrix_CasADi__Matrix_int____size' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____size_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genIMatrix_size' :: GenIMatrixClass a => a -> SparsityType -> IO Int
genIMatrix_size' x = casADi__GenericMatrix_CasADi__Matrix_int____size' (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____dimString" c_CasADi__GenericMatrix_CasADi__Matrix_int____dimString
  :: Ptr GenIMatrix' -> IO (Ptr StdString')
casADi__GenericMatrix_CasADi__Matrix_int____dimString
  :: GenIMatrix -> IO String
casADi__GenericMatrix_CasADi__Matrix_int____dimString x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____dimString x0' >>= wrapReturn

-- classy wrapper
{-|
>Get string representation of dimensions. The representation is (nrow x ncol
>= numel | size)
-}
genIMatrix_dimString :: GenIMatrixClass a => a -> IO String
genIMatrix_dimString x = casADi__GenericMatrix_CasADi__Matrix_int____dimString (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty" c_CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty
  :: Ptr GenIMatrix' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isEmpty
  :: GenIMatrix -> Bool -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isEmpty x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Check if the sparsity is empty, i.e. if one of the dimensions is zero (or
>optionally both dimensions)
-}
genIMatrix_isEmpty :: GenIMatrixClass a => a -> Bool -> IO Bool
genIMatrix_isEmpty x = casADi__GenericMatrix_CasADi__Matrix_int____isEmpty (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty_TIC
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isEmpty'
  :: GenIMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isEmpty' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isEmpty_TIC x0' >>= wrapReturn

-- classy wrapper
genIMatrix_isEmpty' :: GenIMatrixClass a => a -> IO Bool
genIMatrix_isEmpty' x = casADi__GenericMatrix_CasADi__Matrix_int____isEmpty' (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isDense" c_CasADi__GenericMatrix_CasADi__Matrix_int____isDense
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isDense
  :: GenIMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isDense x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isDense x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is dense.
-}
genIMatrix_isDense :: GenIMatrixClass a => a -> IO Bool
genIMatrix_isDense x = casADi__GenericMatrix_CasADi__Matrix_int____isDense (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isScalar" c_CasADi__GenericMatrix_CasADi__Matrix_int____isScalar
  :: Ptr GenIMatrix' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isScalar
  :: GenIMatrix -> Bool -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isScalar x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isScalar x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is scalar.
-}
genIMatrix_isScalar :: GenIMatrixClass a => a -> Bool -> IO Bool
genIMatrix_isScalar x = casADi__GenericMatrix_CasADi__Matrix_int____isScalar (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isScalar_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____isScalar_TIC
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isScalar'
  :: GenIMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isScalar' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isScalar_TIC x0' >>= wrapReturn

-- classy wrapper
genIMatrix_isScalar' :: GenIMatrixClass a => a -> IO Bool
genIMatrix_isScalar' x = casADi__GenericMatrix_CasADi__Matrix_int____isScalar' (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isSquare" c_CasADi__GenericMatrix_CasADi__Matrix_int____isSquare
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isSquare
  :: GenIMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isSquare x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isSquare x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is square.
-}
genIMatrix_isSquare :: GenIMatrixClass a => a -> IO Bool
genIMatrix_isSquare x = casADi__GenericMatrix_CasADi__Matrix_int____isSquare (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isVector" c_CasADi__GenericMatrix_CasADi__Matrix_int____isVector
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isVector
  :: GenIMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isVector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isVector x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is a vector (i.e. size2()==1)
-}
genIMatrix_isVector :: GenIMatrixClass a => a -> IO Bool
genIMatrix_isVector x = casADi__GenericMatrix_CasADi__Matrix_int____isVector (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isTriu" c_CasADi__GenericMatrix_CasADi__Matrix_int____isTriu
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isTriu
  :: GenIMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isTriu x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isTriu x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is upper triangular.
-}
genIMatrix_isTriu :: GenIMatrixClass a => a -> IO Bool
genIMatrix_isTriu x = casADi__GenericMatrix_CasADi__Matrix_int____isTriu (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____isTril" c_CasADi__GenericMatrix_CasADi__Matrix_int____isTril
  :: Ptr GenIMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_int____isTril
  :: GenIMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_int____isTril x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____isTril x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is lower triangular.
-}
genIMatrix_isTril :: GenIMatrixClass a => a -> IO Bool
genIMatrix_isTril x = casADi__GenericMatrix_CasADi__Matrix_int____isTril (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sparsityRef" c_CasADi__GenericMatrix_CasADi__Matrix_int____sparsityRef
  :: Ptr GenIMatrix' -> IO (Ptr Sparsity')
casADi__GenericMatrix_CasADi__Matrix_int____sparsityRef
  :: GenIMatrix -> IO Sparsity
casADi__GenericMatrix_CasADi__Matrix_int____sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sparsityRef x0' >>= wrapReturn

-- classy wrapper
{-|
>Access the sparsity, make a copy if there are multiple references to it.
-}
genIMatrix_sparsityRef :: GenIMatrixClass a => a -> IO Sparsity
genIMatrix_sparsityRef x = casADi__GenericMatrix_CasADi__Matrix_int____sparsityRef (castGenIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sym" c_CasADi__GenericMatrix_CasADi__Matrix_int____sym
  :: Ptr StdString' -> CInt -> CInt -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____sym
  :: String -> Int -> Int -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____sym x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sym x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  static MatType CasADi::GenericMatrix< MatType >::sym(const std::string &name, int nrow=1, int ncol=1)
>------------------------------------------------------------------------
>
>Create an nrow-by-ncol symbolic primitive.
>
>>  static MatType CasADi::GenericMatrix< MatType >::sym(const std::string &name, const std::pair< int, int > &rc)
>------------------------------------------------------------------------
>
>Construct a symbolic primitive with given dimensions.
>
>>  MatType CasADi::GenericMatrix< MatType >::sym(const std::string &name, const Sparsity &sp)
>------------------------------------------------------------------------
>
>Create symbolic primitive with a given sparsity pattern.
>
>>  std::vector< MatType > CasADi::GenericMatrix< MatType >::sym(const std::string &name, const Sparsity &sp, int p)
>------------------------------------------------------------------------
>
>Create a vector of length p with with matrices with symbolic primitives of
>given sparsity.
>
>>  static std::vector<MatType > CasADi::GenericMatrix< MatType >::sym(const std::string &name, int nrow, int ncol, int p)
>------------------------------------------------------------------------
>
>Create a vector of length p with nrow-by-ncol symbolic primitives.
>
>>  std::vector< std::vector< MatType > > CasADi::GenericMatrix< MatType >::sym(const std::string &name, const Sparsity &sp, int p, int r)
>------------------------------------------------------------------------
>
>Create a vector of length r of vectors of length p with symbolic primitives
>with given sparsity.
>
>>  static std::vector<std::vector<MatType> > CasADi::GenericMatrix< MatType >::sym(const std::string &name, int nrow, int ncol, int p, int r)
>------------------------------------------------------------------------
>
>Create a vector of length r of vectors of length p with nrow-by-ncol
>symbolic primitives.
-}
genIMatrix_sym :: String -> Int -> Int -> IO IMatrix
genIMatrix_sym = casADi__GenericMatrix_CasADi__Matrix_int____sym


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC
  :: Ptr StdString' -> CInt -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____sym'
  :: String -> Int -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____sym' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genIMatrix_sym' :: String -> Int -> IO IMatrix
genIMatrix_sym' = casADi__GenericMatrix_CasADi__Matrix_int____sym'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC
  :: Ptr StdString' -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____sym''
  :: String -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____sym'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genIMatrix_sym'' :: String -> IO IMatrix
genIMatrix_sym'' = casADi__GenericMatrix_CasADi__Matrix_int____sym''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____sym'''
  :: String -> Sparsity -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____sym''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genIMatrix_sym''' :: String -> Sparsity -> IO IMatrix
genIMatrix_sym''' = casADi__GenericMatrix_CasADi__Matrix_int____sym'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> CInt -> IO (Ptr (CppVec (Ptr IMatrix')))
casADi__GenericMatrix_CasADi__Matrix_int____sym''''
  :: String -> Sparsity -> Int -> IO (Vector IMatrix)
casADi__GenericMatrix_CasADi__Matrix_int____sym'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
genIMatrix_sym'''' :: String -> Sparsity -> Int -> IO (Vector IMatrix)
genIMatrix_sym'''' = casADi__GenericMatrix_CasADi__Matrix_int____sym''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> CInt -> CInt -> CInt -> IO (Ptr (CppVec (Ptr IMatrix')))
casADi__GenericMatrix_CasADi__Matrix_int____sym'''''
  :: String -> Int -> Int -> Int -> IO (Vector IMatrix)
casADi__GenericMatrix_CasADi__Matrix_int____sym''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
genIMatrix_sym''''' :: String -> Int -> Int -> Int -> IO (Vector IMatrix)
genIMatrix_sym''''' = casADi__GenericMatrix_CasADi__Matrix_int____sym'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (CppVec (Ptr (CppVec (Ptr IMatrix')))))
casADi__GenericMatrix_CasADi__Matrix_int____sym''''''
  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix))
casADi__GenericMatrix_CasADi__Matrix_int____sym'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
genIMatrix_sym'''''' :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix))
genIMatrix_sym'''''' = casADi__GenericMatrix_CasADi__Matrix_int____sym''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (CppVec (Ptr (CppVec (Ptr IMatrix')))))
casADi__GenericMatrix_CasADi__Matrix_int____sym'''''''
  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix))
casADi__GenericMatrix_CasADi__Matrix_int____sym''''''' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
genIMatrix_sym''''''' :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix))
genIMatrix_sym''''''' = casADi__GenericMatrix_CasADi__Matrix_int____sym'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sparse" c_CasADi__GenericMatrix_CasADi__Matrix_int____sparse
  :: CInt -> CInt -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____sparse
  :: Int -> Int -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____sparse x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sparse x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>create a sparse matrix with all zeros
-}
genIMatrix_sparse :: Int -> Int -> IO IMatrix
genIMatrix_sparse = casADi__GenericMatrix_CasADi__Matrix_int____sparse


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC
  :: CInt -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____sparse'
  :: Int -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____sparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC x0' >>= wrapReturn

-- classy wrapper
genIMatrix_sparse' :: Int -> IO IMatrix
genIMatrix_sparse' = casADi__GenericMatrix_CasADi__Matrix_int____sparse'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC_TIC
  :: IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____sparse''
  :: IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____sparse''  =
  c_CasADi__GenericMatrix_CasADi__Matrix_int____sparse_TIC_TIC  >>= wrapReturn

-- classy wrapper
genIMatrix_sparse'' :: IO IMatrix
genIMatrix_sparse'' = casADi__GenericMatrix_CasADi__Matrix_int____sparse''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____zeros" c_CasADi__GenericMatrix_CasADi__Matrix_int____zeros
  :: CInt -> CInt -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____zeros
  :: Int -> Int -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____zeros x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____zeros x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Create a dense matrix or a matrix with specified sparsity with all entries
>zero.
-}
genIMatrix_zeros :: Int -> Int -> IO IMatrix
genIMatrix_zeros = casADi__GenericMatrix_CasADi__Matrix_int____zeros


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC
  :: CInt -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____zeros'
  :: Int -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____zeros' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC x0' >>= wrapReturn

-- classy wrapper
genIMatrix_zeros' :: Int -> IO IMatrix
genIMatrix_zeros' = casADi__GenericMatrix_CasADi__Matrix_int____zeros'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC
  :: IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____zeros''
  :: IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____zeros''  =
  c_CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC  >>= wrapReturn

-- classy wrapper
genIMatrix_zeros'' :: IO IMatrix
genIMatrix_zeros'' = casADi__GenericMatrix_CasADi__Matrix_int____zeros''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____zeros'''
  :: Sparsity -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____zeros''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____zeros_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genIMatrix_zeros''' :: Sparsity -> IO IMatrix
genIMatrix_zeros''' = casADi__GenericMatrix_CasADi__Matrix_int____zeros'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____ones" c_CasADi__GenericMatrix_CasADi__Matrix_int____ones
  :: CInt -> CInt -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____ones
  :: Int -> Int -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____ones x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____ones x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Create a dense matrix or a matrix with specified sparsity with all entries
>one.
-}
genIMatrix_ones :: Int -> Int -> IO IMatrix
genIMatrix_ones = casADi__GenericMatrix_CasADi__Matrix_int____ones


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC
  :: CInt -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____ones'
  :: Int -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____ones' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC x0' >>= wrapReturn

-- classy wrapper
genIMatrix_ones' :: Int -> IO IMatrix
genIMatrix_ones' = casADi__GenericMatrix_CasADi__Matrix_int____ones'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC
  :: IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____ones''
  :: IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____ones''  =
  c_CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC  >>= wrapReturn

-- classy wrapper
genIMatrix_ones'' :: IO IMatrix
genIMatrix_ones'' = casADi__GenericMatrix_CasADi__Matrix_int____ones''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____ones'''
  :: Sparsity -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____ones''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____ones_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genIMatrix_ones''' :: Sparsity -> IO IMatrix
genIMatrix_ones''' = casADi__GenericMatrix_CasADi__Matrix_int____ones'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_int____mul_smart" c_CasADi__GenericMatrix_CasADi__Matrix_int____mul_smart
  :: Ptr GenIMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__GenericMatrix_CasADi__Matrix_int____mul_smart
  :: GenIMatrix -> IMatrix -> Sparsity -> IO IMatrix
casADi__GenericMatrix_CasADi__Matrix_int____mul_smart x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_int____mul_smart x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Matrix-matrix multiplication. Attempts to identify quick returns on matrix-
>level and delegates to MatType::mul_full if no such quick returns are found.
-}
genIMatrix_mul_smart :: GenIMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix
genIMatrix_mul_smart x = casADi__GenericMatrix_CasADi__Matrix_int____mul_smart (castGenIMatrix x)