GenMX.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.GenMX
       (
         GenMX,
         GenMXClass(..),
         genMX_dimString,
         genMX_isDense,
         genMX_isEmpty,
         genMX_isEmpty',
         genMX_isScalar,
         genMX_isScalar',
         genMX_isSquare,
         genMX_isTril,
         genMX_isTriu,
         genMX_isVector,
         genMX_mul_smart,
         genMX_numel,
         genMX_ones,
         genMX_ones',
         genMX_ones'',
         genMX_ones''',
         genMX_size,
         genMX_size',
         genMX_size1,
         genMX_size2,
         genMX_sizeD,
         genMX_sizeL,
         genMX_sizeU,
         genMX_sparse,
         genMX_sparse',
         genMX_sparse'',
         genMX_sparsityRef,
         genMX_sym,
         genMX_sym',
         genMX_sym'',
         genMX_sym''',
         genMX_sym'''',
         genMX_sym''''',
         genMX_sym'''''',
         genMX_sym''''''',
         genMX_zeros,
         genMX_zeros',
         genMX_zeros'',
         genMX_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__MX___size" c_CasADi__GenericMatrix_CasADi__MX___size
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___size
  :: GenMX -> IO Int
casADi__GenericMatrix_CasADi__MX___size x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___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.
-}
genMX_size :: GenMXClass a => a -> IO Int
genMX_size x = casADi__GenericMatrix_CasADi__MX___size (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sizeL" c_CasADi__GenericMatrix_CasADi__MX___sizeL
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___sizeL
  :: GenMX -> IO Int
casADi__GenericMatrix_CasADi__MX___sizeL x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___sizeL x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of non-zeros in the lower triangular half.
-}
genMX_sizeL :: GenMXClass a => a -> IO Int
genMX_sizeL x = casADi__GenericMatrix_CasADi__MX___sizeL (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sizeU" c_CasADi__GenericMatrix_CasADi__MX___sizeU
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___sizeU
  :: GenMX -> IO Int
casADi__GenericMatrix_CasADi__MX___sizeU x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___sizeU x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of non-zeros in the upper triangular half.
-}
genMX_sizeU :: GenMXClass a => a -> IO Int
genMX_sizeU x = casADi__GenericMatrix_CasADi__MX___sizeU (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sizeD" c_CasADi__GenericMatrix_CasADi__MX___sizeD
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___sizeD
  :: GenMX -> IO Int
casADi__GenericMatrix_CasADi__MX___sizeD x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___sizeD x0' >>= wrapReturn

-- classy wrapper
{-|
>Get get the number of non-zeros on the diagonal.
-}
genMX_sizeD :: GenMXClass a => a -> IO Int
genMX_sizeD x = casADi__GenericMatrix_CasADi__MX___sizeD (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___numel" c_CasADi__GenericMatrix_CasADi__MX___numel
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___numel
  :: GenMX -> IO Int
casADi__GenericMatrix_CasADi__MX___numel x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___numel x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of elements.
-}
genMX_numel :: GenMXClass a => a -> IO Int
genMX_numel x = casADi__GenericMatrix_CasADi__MX___numel (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___size1" c_CasADi__GenericMatrix_CasADi__MX___size1
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___size1
  :: GenMX -> IO Int
casADi__GenericMatrix_CasADi__MX___size1 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___size1 x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the first dimension (i.e. number of rows)
-}
genMX_size1 :: GenMXClass a => a -> IO Int
genMX_size1 x = casADi__GenericMatrix_CasADi__MX___size1 (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___size2" c_CasADi__GenericMatrix_CasADi__MX___size2
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___size2
  :: GenMX -> IO Int
casADi__GenericMatrix_CasADi__MX___size2 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___size2 x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the second dimension (i.e. number of columns)
-}
genMX_size2 :: GenMXClass a => a -> IO Int
genMX_size2 x = casADi__GenericMatrix_CasADi__MX___size2 (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___size_TIC" c_CasADi__GenericMatrix_CasADi__MX___size_TIC
  :: Ptr GenMX' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__MX___size'
  :: GenMX -> SparsityType -> IO Int
casADi__GenericMatrix_CasADi__MX___size' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__MX___size_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genMX_size' :: GenMXClass a => a -> SparsityType -> IO Int
genMX_size' x = casADi__GenericMatrix_CasADi__MX___size' (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___dimString" c_CasADi__GenericMatrix_CasADi__MX___dimString
  :: Ptr GenMX' -> IO (Ptr StdString')
casADi__GenericMatrix_CasADi__MX___dimString
  :: GenMX -> IO String
casADi__GenericMatrix_CasADi__MX___dimString x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___dimString x0' >>= wrapReturn

-- classy wrapper
{-|
>Get string representation of dimensions. The representation is (nrow x ncol
>= numel | size)
-}
genMX_dimString :: GenMXClass a => a -> IO String
genMX_dimString x = casADi__GenericMatrix_CasADi__MX___dimString (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isEmpty" c_CasADi__GenericMatrix_CasADi__MX___isEmpty
  :: Ptr GenMX' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__MX___isEmpty
  :: GenMX -> Bool -> IO Bool
casADi__GenericMatrix_CasADi__MX___isEmpty x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__MX___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)
-}
genMX_isEmpty :: GenMXClass a => a -> Bool -> IO Bool
genMX_isEmpty x = casADi__GenericMatrix_CasADi__MX___isEmpty (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isEmpty_TIC" c_CasADi__GenericMatrix_CasADi__MX___isEmpty_TIC
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___isEmpty'
  :: GenMX -> IO Bool
casADi__GenericMatrix_CasADi__MX___isEmpty' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___isEmpty_TIC x0' >>= wrapReturn

-- classy wrapper
genMX_isEmpty' :: GenMXClass a => a -> IO Bool
genMX_isEmpty' x = casADi__GenericMatrix_CasADi__MX___isEmpty' (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isDense" c_CasADi__GenericMatrix_CasADi__MX___isDense
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___isDense
  :: GenMX -> IO Bool
casADi__GenericMatrix_CasADi__MX___isDense x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___isDense x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is dense.
-}
genMX_isDense :: GenMXClass a => a -> IO Bool
genMX_isDense x = casADi__GenericMatrix_CasADi__MX___isDense (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isScalar" c_CasADi__GenericMatrix_CasADi__MX___isScalar
  :: Ptr GenMX' -> CInt -> IO CInt
casADi__GenericMatrix_CasADi__MX___isScalar
  :: GenMX -> Bool -> IO Bool
casADi__GenericMatrix_CasADi__MX___isScalar x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__MX___isScalar x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is scalar.
-}
genMX_isScalar :: GenMXClass a => a -> Bool -> IO Bool
genMX_isScalar x = casADi__GenericMatrix_CasADi__MX___isScalar (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isScalar_TIC" c_CasADi__GenericMatrix_CasADi__MX___isScalar_TIC
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___isScalar'
  :: GenMX -> IO Bool
casADi__GenericMatrix_CasADi__MX___isScalar' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___isScalar_TIC x0' >>= wrapReturn

-- classy wrapper
genMX_isScalar' :: GenMXClass a => a -> IO Bool
genMX_isScalar' x = casADi__GenericMatrix_CasADi__MX___isScalar' (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isSquare" c_CasADi__GenericMatrix_CasADi__MX___isSquare
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___isSquare
  :: GenMX -> IO Bool
casADi__GenericMatrix_CasADi__MX___isSquare x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___isSquare x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix expression is square.
-}
genMX_isSquare :: GenMXClass a => a -> IO Bool
genMX_isSquare x = casADi__GenericMatrix_CasADi__MX___isSquare (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isVector" c_CasADi__GenericMatrix_CasADi__MX___isVector
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___isVector
  :: GenMX -> IO Bool
casADi__GenericMatrix_CasADi__MX___isVector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___isVector x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is a vector (i.e. size2()==1)
-}
genMX_isVector :: GenMXClass a => a -> IO Bool
genMX_isVector x = casADi__GenericMatrix_CasADi__MX___isVector (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isTriu" c_CasADi__GenericMatrix_CasADi__MX___isTriu
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___isTriu
  :: GenMX -> IO Bool
casADi__GenericMatrix_CasADi__MX___isTriu x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___isTriu x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is upper triangular.
-}
genMX_isTriu :: GenMXClass a => a -> IO Bool
genMX_isTriu x = casADi__GenericMatrix_CasADi__MX___isTriu (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___isTril" c_CasADi__GenericMatrix_CasADi__MX___isTril
  :: Ptr GenMX' -> IO CInt
casADi__GenericMatrix_CasADi__MX___isTril
  :: GenMX -> IO Bool
casADi__GenericMatrix_CasADi__MX___isTril x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___isTril x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the matrix is lower triangular.
-}
genMX_isTril :: GenMXClass a => a -> IO Bool
genMX_isTril x = casADi__GenericMatrix_CasADi__MX___isTril (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sparsityRef" c_CasADi__GenericMatrix_CasADi__MX___sparsityRef
  :: Ptr GenMX' -> IO (Ptr Sparsity')
casADi__GenericMatrix_CasADi__MX___sparsityRef
  :: GenMX -> IO Sparsity
casADi__GenericMatrix_CasADi__MX___sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___sparsityRef x0' >>= wrapReturn

-- classy wrapper
{-|
>Access the sparsity, make a copy if there are multiple references to it.
-}
genMX_sparsityRef :: GenMXClass a => a -> IO Sparsity
genMX_sparsityRef x = casADi__GenericMatrix_CasADi__MX___sparsityRef (castGenMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sym" c_CasADi__GenericMatrix_CasADi__MX___sym
  :: Ptr StdString' -> CInt -> CInt -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___sym
  :: String -> Int -> Int -> IO MX
casADi__GenericMatrix_CasADi__MX___sym x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__MX___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.
-}
genMX_sym :: String -> Int -> Int -> IO MX
genMX_sym = casADi__GenericMatrix_CasADi__MX___sym


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sym_TIC" c_CasADi__GenericMatrix_CasADi__MX___sym_TIC
  :: Ptr StdString' -> CInt -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___sym'
  :: String -> Int -> IO MX
casADi__GenericMatrix_CasADi__MX___sym' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__MX___sym_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genMX_sym' :: String -> Int -> IO MX
genMX_sym' = casADi__GenericMatrix_CasADi__MX___sym'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC
  :: Ptr StdString' -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___sym''
  :: String -> IO MX
casADi__GenericMatrix_CasADi__MX___sym'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genMX_sym'' :: String -> IO MX
genMX_sym'' = casADi__GenericMatrix_CasADi__MX___sym''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___sym'''
  :: String -> Sparsity -> IO MX
casADi__GenericMatrix_CasADi__MX___sym''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
genMX_sym''' :: String -> Sparsity -> IO MX
genMX_sym''' = casADi__GenericMatrix_CasADi__MX___sym'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> CInt -> IO (Ptr (CppVec (Ptr MX')))
casADi__GenericMatrix_CasADi__MX___sym''''
  :: String -> Sparsity -> Int -> IO (Vector MX)
casADi__GenericMatrix_CasADi__MX___sym'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
genMX_sym'''' :: String -> Sparsity -> Int -> IO (Vector MX)
genMX_sym'''' = casADi__GenericMatrix_CasADi__MX___sym''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> CInt -> CInt -> CInt -> IO (Ptr (CppVec (Ptr MX')))
casADi__GenericMatrix_CasADi__MX___sym'''''
  :: String -> Int -> Int -> Int -> IO (Vector MX)
casADi__GenericMatrix_CasADi__MX___sym''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
genMX_sym''''' :: String -> Int -> Int -> Int -> IO (Vector MX)
genMX_sym''''' = casADi__GenericMatrix_CasADi__MX___sym'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (CppVec (Ptr (CppVec (Ptr MX')))))
casADi__GenericMatrix_CasADi__MX___sym''''''
  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX))
casADi__GenericMatrix_CasADi__MX___sym'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
genMX_sym'''''' :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX))
genMX_sym'''''' = casADi__GenericMatrix_CasADi__MX___sym''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr StdString' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (CppVec (Ptr (CppVec (Ptr MX')))))
casADi__GenericMatrix_CasADi__MX___sym'''''''
  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))
casADi__GenericMatrix_CasADi__MX___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__MX___sym_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
genMX_sym''''''' :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))
genMX_sym''''''' = casADi__GenericMatrix_CasADi__MX___sym'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sparse" c_CasADi__GenericMatrix_CasADi__MX___sparse
  :: CInt -> CInt -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___sparse
  :: Int -> Int -> IO MX
casADi__GenericMatrix_CasADi__MX___sparse x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__MX___sparse x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>create a sparse matrix with all zeros
-}
genMX_sparse :: Int -> Int -> IO MX
genMX_sparse = casADi__GenericMatrix_CasADi__MX___sparse


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sparse_TIC" c_CasADi__GenericMatrix_CasADi__MX___sparse_TIC
  :: CInt -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___sparse'
  :: Int -> IO MX
casADi__GenericMatrix_CasADi__MX___sparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___sparse_TIC x0' >>= wrapReturn

-- classy wrapper
genMX_sparse' :: Int -> IO MX
genMX_sparse' = casADi__GenericMatrix_CasADi__MX___sparse'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___sparse_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___sparse_TIC_TIC
  :: IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___sparse''
  :: IO MX
casADi__GenericMatrix_CasADi__MX___sparse''  =
  c_CasADi__GenericMatrix_CasADi__MX___sparse_TIC_TIC  >>= wrapReturn

-- classy wrapper
genMX_sparse'' :: IO MX
genMX_sparse'' = casADi__GenericMatrix_CasADi__MX___sparse''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___zeros" c_CasADi__GenericMatrix_CasADi__MX___zeros
  :: CInt -> CInt -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___zeros
  :: Int -> Int -> IO MX
casADi__GenericMatrix_CasADi__MX___zeros x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__MX___zeros x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Create a dense matrix or a matrix with specified sparsity with all entries
>zero.
-}
genMX_zeros :: Int -> Int -> IO MX
genMX_zeros = casADi__GenericMatrix_CasADi__MX___zeros


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___zeros_TIC" c_CasADi__GenericMatrix_CasADi__MX___zeros_TIC
  :: CInt -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___zeros'
  :: Int -> IO MX
casADi__GenericMatrix_CasADi__MX___zeros' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___zeros_TIC x0' >>= wrapReturn

-- classy wrapper
genMX_zeros' :: Int -> IO MX
genMX_zeros' = casADi__GenericMatrix_CasADi__MX___zeros'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC
  :: IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___zeros''
  :: IO MX
casADi__GenericMatrix_CasADi__MX___zeros''  =
  c_CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC  >>= wrapReturn

-- classy wrapper
genMX_zeros'' :: IO MX
genMX_zeros'' = casADi__GenericMatrix_CasADi__MX___zeros''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___zeros'''
  :: Sparsity -> IO MX
casADi__GenericMatrix_CasADi__MX___zeros''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___zeros_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genMX_zeros''' :: Sparsity -> IO MX
genMX_zeros''' = casADi__GenericMatrix_CasADi__MX___zeros'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___ones" c_CasADi__GenericMatrix_CasADi__MX___ones
  :: CInt -> CInt -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___ones
  :: Int -> Int -> IO MX
casADi__GenericMatrix_CasADi__MX___ones x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__GenericMatrix_CasADi__MX___ones x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Create a dense matrix or a matrix with specified sparsity with all entries
>one.
-}
genMX_ones :: Int -> Int -> IO MX
genMX_ones = casADi__GenericMatrix_CasADi__MX___ones


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___ones_TIC" c_CasADi__GenericMatrix_CasADi__MX___ones_TIC
  :: CInt -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___ones'
  :: Int -> IO MX
casADi__GenericMatrix_CasADi__MX___ones' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___ones_TIC x0' >>= wrapReturn

-- classy wrapper
genMX_ones' :: Int -> IO MX
genMX_ones' = casADi__GenericMatrix_CasADi__MX___ones'


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC
  :: IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___ones''
  :: IO MX
casADi__GenericMatrix_CasADi__MX___ones''  =
  c_CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC  >>= wrapReturn

-- classy wrapper
genMX_ones'' :: IO MX
genMX_ones'' = casADi__GenericMatrix_CasADi__MX___ones''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC_TIC" c_CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___ones'''
  :: Sparsity -> IO MX
casADi__GenericMatrix_CasADi__MX___ones''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__GenericMatrix_CasADi__MX___ones_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
genMX_ones''' :: Sparsity -> IO MX
genMX_ones''' = casADi__GenericMatrix_CasADi__MX___ones'''


-- direct wrapper
foreign import ccall unsafe "CasADi__GenericMatrix_CasADi__MX___mul_smart" c_CasADi__GenericMatrix_CasADi__MX___mul_smart
  :: Ptr GenMX' -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
casADi__GenericMatrix_CasADi__MX___mul_smart
  :: GenMX -> MX -> Sparsity -> IO MX
casADi__GenericMatrix_CasADi__MX___mul_smart x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__GenericMatrix_CasADi__MX___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.
-}
genMX_mul_smart :: GenMXClass a => a -> MX -> Sparsity -> IO MX
genMX_mul_smart x = casADi__GenericMatrix_CasADi__MX___mul_smart (castGenMX x)