GenDMatrix.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.GenDMatrix
       (
         GenDMatrix,
         GenDMatrixClass(..),
         genDMatrix_dimString,
         genDMatrix_isDense,
         genDMatrix_isEmpty,
         genDMatrix_isEmpty',
         genDMatrix_isScalar,
         genDMatrix_isScalar',
         genDMatrix_isSquare,
         genDMatrix_isTril,
         genDMatrix_isTriu,
         genDMatrix_isVector,
         genDMatrix_mul_smart,
         genDMatrix_numel,
         genDMatrix_ones,
         genDMatrix_ones',
         genDMatrix_ones'',
         genDMatrix_ones''',
         genDMatrix_size,
         genDMatrix_size',
         genDMatrix_size1,
         genDMatrix_size2,
         genDMatrix_sizeD,
         genDMatrix_sizeL,
         genDMatrix_sizeU,
         genDMatrix_sparse,
         genDMatrix_sparse',
         genDMatrix_sparse'',
         genDMatrix_sparsityRef,
         genDMatrix_sym,
         genDMatrix_sym',
         genDMatrix_sym'',
         genDMatrix_sym''',
         genDMatrix_sym'''',
         genDMatrix_sym''''',
         genDMatrix_sym'''''',
         genDMatrix_sym''''''',
         genDMatrix_zeros,
         genDMatrix_zeros',
         genDMatrix_zeros'',
         genDMatrix_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_double____size" c_CasADi__GenericMatrix_CasADi__Matrix_double____size
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____size
  :: GenDMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_double____size x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____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.
-}
genDMatrix_size :: GenDMatrixClass a => a -> IO Int
genDMatrix_size x = casADi__GenericMatrix_CasADi__Matrix_double____size (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sizeL" c_CasADi__GenericMatrix_CasADi__Matrix_double____sizeL
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____sizeL
  :: GenDMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_double____sizeL x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sizeL x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of non-zeros in the lower triangular half.
-}
genDMatrix_sizeL :: GenDMatrixClass a => a -> IO Int
genDMatrix_sizeL x = casADi__GenericMatrix_CasADi__Matrix_double____sizeL (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sizeU" c_CasADi__GenericMatrix_CasADi__Matrix_double____sizeU
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____sizeU
  :: GenDMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_double____sizeU x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sizeU x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of non-zeros in the upper triangular half.
-}
genDMatrix_sizeU :: GenDMatrixClass a => a -> IO Int
genDMatrix_sizeU x = casADi__GenericMatrix_CasADi__Matrix_double____sizeU (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sizeD" c_CasADi__GenericMatrix_CasADi__Matrix_double____sizeD
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____sizeD
  :: GenDMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_double____sizeD x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sizeD x0' >>= wrapReturn

-- classy wrapper
{-|
>Get get the number of non-zeros on the diagonal.
-}
genDMatrix_sizeD :: GenDMatrixClass a => a -> IO Int
genDMatrix_sizeD x = casADi__GenericMatrix_CasADi__Matrix_double____sizeD (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____numel" c_CasADi__GenericMatrix_CasADi__Matrix_double____numel
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____numel
  :: GenDMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_double____numel x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____numel x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of elements.
-}
genDMatrix_numel :: GenDMatrixClass a => a -> IO Int
genDMatrix_numel x = casADi__GenericMatrix_CasADi__Matrix_double____numel (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____size1" c_CasADi__GenericMatrix_CasADi__Matrix_double____size1
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____size1
  :: GenDMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_double____size1 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____size1 x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the first dimension (i.e. number of rows)
-}
genDMatrix_size1 :: GenDMatrixClass a => a -> IO Int
genDMatrix_size1 x = casADi__GenericMatrix_CasADi__Matrix_double____size1 (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____size2" c_CasADi__GenericMatrix_CasADi__Matrix_double____size2
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____size2
  :: GenDMatrix -> IO Int
casADi__GenericMatrix_CasADi__Matrix_double____size2 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____size2 x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the second dimension (i.e. number of columns)
-}
genDMatrix_size2 :: GenDMatrixClass a => a -> IO Int
genDMatrix_size2 x = casADi__GenericMatrix_CasADi__Matrix_double____size2 (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____size_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____size_TIC
  :: Ptr GenDMatrix' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____size'
  :: GenDMatrix -> SparsityType -> IO Int
casADi__GenericMatrix_CasADi__Matrix_double____size' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____size_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genDMatrix_size' :: GenDMatrixClass a => a -> SparsityType -> IO Int
genDMatrix_size' x = casADi__GenericMatrix_CasADi__Matrix_double____size' (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____dimString" c_CasADi__GenericMatrix_CasADi__Matrix_double____dimString
  :: Ptr GenDMatrix' -> IO (Ptr StdString')
casADi__GenericMatrix_CasADi__Matrix_double____dimString
  :: GenDMatrix -> IO String
casADi__GenericMatrix_CasADi__Matrix_double____dimString x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____dimString x0' >>= wrapReturn

-- classy wrapper
{-|
>Get string representation of dimensions. The representation is (nrow x ncol
>= numel | size)
-}
genDMatrix_dimString :: GenDMatrixClass a => a -> IO String
genDMatrix_dimString x = casADi__GenericMatrix_CasADi__Matrix_double____dimString (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty" c_CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty
  :: Ptr GenDMatrix' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isEmpty
  :: GenDMatrix -> Bool -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isEmpty x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____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)
-}
genDMatrix_isEmpty :: GenDMatrixClass a => a -> Bool -> IO Bool
genDMatrix_isEmpty x = casADi__GenericMatrix_CasADi__Matrix_double____isEmpty (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty_TIC
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isEmpty'
  :: GenDMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isEmpty' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____isEmpty_TIC x0' >>= wrapReturn

-- classy wrapper
genDMatrix_isEmpty' :: GenDMatrixClass a => a -> IO Bool
genDMatrix_isEmpty' x = casADi__GenericMatrix_CasADi__Matrix_double____isEmpty' (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isDense" c_CasADi__GenericMatrix_CasADi__Matrix_double____isDense
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isDense
  :: GenDMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isDense x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____isDense x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is dense.
-}
genDMatrix_isDense :: GenDMatrixClass a => a -> IO Bool
genDMatrix_isDense x = casADi__GenericMatrix_CasADi__Matrix_double____isDense (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isScalar" c_CasADi__GenericMatrix_CasADi__Matrix_double____isScalar
  :: Ptr GenDMatrix' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isScalar
  :: GenDMatrix -> Bool -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isScalar x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____isScalar x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is scalar.
-}
genDMatrix_isScalar :: GenDMatrixClass a => a -> Bool -> IO Bool
genDMatrix_isScalar x = casADi__GenericMatrix_CasADi__Matrix_double____isScalar (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isScalar_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____isScalar_TIC
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isScalar'
  :: GenDMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isScalar' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____isScalar_TIC x0' >>= wrapReturn

-- classy wrapper
genDMatrix_isScalar' :: GenDMatrixClass a => a -> IO Bool
genDMatrix_isScalar' x = casADi__GenericMatrix_CasADi__Matrix_double____isScalar' (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isSquare" c_CasADi__GenericMatrix_CasADi__Matrix_double____isSquare
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isSquare
  :: GenDMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isSquare x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____isSquare x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is square.
-}
genDMatrix_isSquare :: GenDMatrixClass a => a -> IO Bool
genDMatrix_isSquare x = casADi__GenericMatrix_CasADi__Matrix_double____isSquare (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isVector" c_CasADi__GenericMatrix_CasADi__Matrix_double____isVector
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isVector
  :: GenDMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isVector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____isVector x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is a vector (i.e. size2()==1)
-}
genDMatrix_isVector :: GenDMatrixClass a => a -> IO Bool
genDMatrix_isVector x = casADi__GenericMatrix_CasADi__Matrix_double____isVector (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isTriu" c_CasADi__GenericMatrix_CasADi__Matrix_double____isTriu
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isTriu
  :: GenDMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isTriu x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____isTriu x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is upper triangular.
-}
genDMatrix_isTriu :: GenDMatrixClass a => a -> IO Bool
genDMatrix_isTriu x = casADi__GenericMatrix_CasADi__Matrix_double____isTriu (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____isTril" c_CasADi__GenericMatrix_CasADi__Matrix_double____isTril
  :: Ptr GenDMatrix' -> IO CInt
casADi__GenericMatrix_CasADi__Matrix_double____isTril
  :: GenDMatrix -> IO Bool
casADi__GenericMatrix_CasADi__Matrix_double____isTril x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____isTril x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is lower triangular.
-}
genDMatrix_isTril :: GenDMatrixClass a => a -> IO Bool
genDMatrix_isTril x = casADi__GenericMatrix_CasADi__Matrix_double____isTril (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sparsityRef" c_CasADi__GenericMatrix_CasADi__Matrix_double____sparsityRef
  :: Ptr GenDMatrix' -> IO (Ptr Sparsity')
casADi__GenericMatrix_CasADi__Matrix_double____sparsityRef
  :: GenDMatrix -> IO Sparsity
casADi__GenericMatrix_CasADi__Matrix_double____sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sparsityRef x0' >>= wrapReturn

-- classy wrapper
{-|
>Access the sparsity, make a copy if there are multiple references to it.
-}
genDMatrix_sparsityRef :: GenDMatrixClass a => a -> IO Sparsity
genDMatrix_sparsityRef x = casADi__GenericMatrix_CasADi__Matrix_double____sparsityRef (castGenDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sym" c_CasADi__GenericMatrix_CasADi__Matrix_double____sym
  :: Ptr StdString' -> CInt -> CInt -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____sym
  :: String -> Int -> Int -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____sym x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____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.
-}
genDMatrix_sym :: String -> Int -> Int -> IO DMatrix
genDMatrix_sym = casADi__GenericMatrix_CasADi__Matrix_double____sym


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC
  :: Ptr StdString' -> CInt -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____sym'
  :: String -> Int -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____sym' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genDMatrix_sym' :: String -> Int -> IO DMatrix
genDMatrix_sym' = casADi__GenericMatrix_CasADi__Matrix_double____sym'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC
  :: Ptr StdString' -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____sym''
  :: String -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____sym'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genDMatrix_sym'' :: String -> IO DMatrix
genDMatrix_sym'' = casADi__GenericMatrix_CasADi__Matrix_double____sym''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____sym'''
  :: String -> Sparsity -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____sym''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genDMatrix_sym''' :: String -> Sparsity -> IO DMatrix
genDMatrix_sym''' = casADi__GenericMatrix_CasADi__Matrix_double____sym'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> CInt -> IO (Ptr (CppVec (Ptr DMatrix')))
casADi__GenericMatrix_CasADi__Matrix_double____sym''''
  :: String -> Sparsity -> Int -> IO (Vector DMatrix)
casADi__GenericMatrix_CasADi__Matrix_double____sym'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
genDMatrix_sym'''' :: String -> Sparsity -> Int -> IO (Vector DMatrix)
genDMatrix_sym'''' = casADi__GenericMatrix_CasADi__Matrix_double____sym''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> CInt -> CInt -> CInt -> IO (Ptr (CppVec (Ptr DMatrix')))
casADi__GenericMatrix_CasADi__Matrix_double____sym'''''
  :: String -> Int -> Int -> Int -> IO (Vector DMatrix)
casADi__GenericMatrix_CasADi__Matrix_double____sym''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
genDMatrix_sym''''' :: String -> Int -> Int -> Int -> IO (Vector DMatrix)
genDMatrix_sym''''' = casADi__GenericMatrix_CasADi__Matrix_double____sym'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (CppVec (Ptr (CppVec (Ptr DMatrix')))))
casADi__GenericMatrix_CasADi__Matrix_double____sym''''''
  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix))
casADi__GenericMatrix_CasADi__Matrix_double____sym'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
genDMatrix_sym'''''' :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix))
genDMatrix_sym'''''' = casADi__GenericMatrix_CasADi__Matrix_double____sym''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (CppVec (Ptr (CppVec (Ptr DMatrix')))))
casADi__GenericMatrix_CasADi__Matrix_double____sym'''''''
  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix))
casADi__GenericMatrix_CasADi__Matrix_double____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_double____sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
genDMatrix_sym''''''' :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix))
genDMatrix_sym''''''' = casADi__GenericMatrix_CasADi__Matrix_double____sym'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sparse" c_CasADi__GenericMatrix_CasADi__Matrix_double____sparse
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____sparse
  :: Int -> Int -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____sparse x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sparse x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>create a sparse matrix with all zeros
-}
genDMatrix_sparse :: Int -> Int -> IO DMatrix
genDMatrix_sparse = casADi__GenericMatrix_CasADi__Matrix_double____sparse


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC
  :: CInt -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____sparse'
  :: Int -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____sparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC x0' >>= wrapReturn

-- classy wrapper
genDMatrix_sparse' :: Int -> IO DMatrix
genDMatrix_sparse' = casADi__GenericMatrix_CasADi__Matrix_double____sparse'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC_TIC
  :: IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____sparse''
  :: IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____sparse''  =
  c_CasADi__GenericMatrix_CasADi__Matrix_double____sparse_TIC_TIC  >>= wrapReturn

-- classy wrapper
genDMatrix_sparse'' :: IO DMatrix
genDMatrix_sparse'' = casADi__GenericMatrix_CasADi__Matrix_double____sparse''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____zeros" c_CasADi__GenericMatrix_CasADi__Matrix_double____zeros
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____zeros
  :: Int -> Int -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____zeros x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____zeros x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Create a dense matrix or a matrix with specified sparsity with all entries
>zero.
-}
genDMatrix_zeros :: Int -> Int -> IO DMatrix
genDMatrix_zeros = casADi__GenericMatrix_CasADi__Matrix_double____zeros


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC
  :: CInt -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____zeros'
  :: Int -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____zeros' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC x0' >>= wrapReturn

-- classy wrapper
genDMatrix_zeros' :: Int -> IO DMatrix
genDMatrix_zeros' = casADi__GenericMatrix_CasADi__Matrix_double____zeros'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC
  :: IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____zeros''
  :: IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____zeros''  =
  c_CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC  >>= wrapReturn

-- classy wrapper
genDMatrix_zeros'' :: IO DMatrix
genDMatrix_zeros'' = casADi__GenericMatrix_CasADi__Matrix_double____zeros''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____zeros'''
  :: Sparsity -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____zeros''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____zeros_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genDMatrix_zeros''' :: Sparsity -> IO DMatrix
genDMatrix_zeros''' = casADi__GenericMatrix_CasADi__Matrix_double____zeros'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____ones" c_CasADi__GenericMatrix_CasADi__Matrix_double____ones
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____ones
  :: Int -> Int -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____ones x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____ones x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Create a dense matrix or a matrix with specified sparsity with all entries
>one.
-}
genDMatrix_ones :: Int -> Int -> IO DMatrix
genDMatrix_ones = casADi__GenericMatrix_CasADi__Matrix_double____ones


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC
  :: CInt -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____ones'
  :: Int -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____ones' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC x0' >>= wrapReturn

-- classy wrapper
genDMatrix_ones' :: Int -> IO DMatrix
genDMatrix_ones' = casADi__GenericMatrix_CasADi__Matrix_double____ones'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC
  :: IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____ones''
  :: IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____ones''  =
  c_CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC  >>= wrapReturn

-- classy wrapper
genDMatrix_ones'' :: IO DMatrix
genDMatrix_ones'' = casADi__GenericMatrix_CasADi__Matrix_double____ones''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____ones'''
  :: Sparsity -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____ones''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____ones_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genDMatrix_ones''' :: Sparsity -> IO DMatrix
genDMatrix_ones''' = casADi__GenericMatrix_CasADi__Matrix_double____ones'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__Matrix_double____mul_smart" c_CasADi__GenericMatrix_CasADi__Matrix_double____mul_smart
  :: Ptr GenDMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
casADi__GenericMatrix_CasADi__Matrix_double____mul_smart
  :: GenDMatrix -> DMatrix -> Sparsity -> IO DMatrix
casADi__GenericMatrix_CasADi__Matrix_double____mul_smart x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__Matrix_double____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.
-}
genDMatrix_mul_smart :: GenDMatrixClass a => a -> DMatrix -> Sparsity -> IO DMatrix
genDMatrix_mul_smart x = casADi__GenericMatrix_CasADi__Matrix_double____mul_smart (castGenDMatrix x)