casadi-bindings-1.8.0.0: Casadi/Wrappers/Classes/SXMatrix.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.SXMatrix
       (
         SXMatrix,
         SXMatrixClass(..),
         sxMatrix,
         sxMatrix',
         sxMatrix'',
         sxMatrix''',
         sxMatrix'''',
         sxMatrix''''',
         sxMatrix'''''',
         sxMatrix''''''',
         sxMatrix'''''''',
         sxMatrix''''''''',
         sxMatrix'''''''''',
         sxMatrix''''''''''',
         sxMatrix'''''''''''',
         sxMatrix___add__,
         sxMatrix___constpow__,
         sxMatrix___div__,
         sxMatrix___eq__,
         sxMatrix___le__,
         sxMatrix___lt__,
         sxMatrix___mpower__,
         sxMatrix___mrdivide__,
         sxMatrix___mul__,
         sxMatrix___ne__,
         sxMatrix___nonzero__,
         sxMatrix___pow__,
         sxMatrix___sub__,
         sxMatrix___truediv__,
         sxMatrix_append,
         sxMatrix_arccos,
         sxMatrix_arccosh,
         sxMatrix_arcsin,
         sxMatrix_arcsinh,
         sxMatrix_arctan,
         sxMatrix_arctan2,
         sxMatrix_arctanh,
         sxMatrix_at,
         sxMatrix_binary,
         sxMatrix_ceil,
         sxMatrix_className,
         sxMatrix_clear,
         sxMatrix_col,
         sxMatrix_cos,
         sxMatrix_cosh,
         sxMatrix_data,
         sxMatrix_elem,
         sxMatrix_elem',
         sxMatrix_enlarge,
         sxMatrix_erase,
         sxMatrix_erf,
         sxMatrix_erfinv,
         sxMatrix_exp,
         sxMatrix_eye,
         sxMatrix_fabs,
         sxMatrix_floor,
         sxMatrix_fmax,
         sxMatrix_fmin,
         sxMatrix_get,
         sxMatrix_get',
         sxMatrix_get'',
         sxMatrix_get''',
         sxMatrix_get'''',
         sxMatrix_get''''',
         sxMatrix_hasNZ,
         sxMatrix_if_else_zero,
         sxMatrix_inf,
         sxMatrix_inf',
         sxMatrix_inf'',
         sxMatrix_inf''',
         sxMatrix_isNull,
         sxMatrix_log,
         sxMatrix_log10,
         sxMatrix_logic_and,
         sxMatrix_logic_not,
         sxMatrix_logic_or,
         sxMatrix_matrix_matrix,
         sxMatrix_matrix_scalar,
         sxMatrix_mul,
         sxMatrix_mul',
         sxMatrix_mul_full,
         sxMatrix_mul_full',
         sxMatrix_mul_no_alloc_nn,
         sxMatrix_mul_no_alloc_nn',
         sxMatrix_mul_no_alloc_nt,
         sxMatrix_mul_no_alloc_tn,
         sxMatrix_mul_no_alloc_tn',
         sxMatrix_nan,
         sxMatrix_nan',
         sxMatrix_nan'',
         sxMatrix_nan''',
         sxMatrix_numel,
         sxMatrix_ones,
         sxMatrix_ones',
         sxMatrix_ones'',
         sxMatrix_operator_minus,
         sxMatrix_operator_plus,
         sxMatrix_printDense',
         sxMatrix_printMatrix',
         sxMatrix_printScalar',
         sxMatrix_printSparse',
         sxMatrix_printVector',
         sxMatrix_printme,
         sxMatrix_quad_form,
         sxMatrix_remove,
         sxMatrix_repmat,
         sxMatrix_repmat',
         sxMatrix_reserve,
         sxMatrix_reserve',
         sxMatrix_resize,
         sxMatrix_rowind,
         sxMatrix_sanityCheck,
         sxMatrix_sanityCheck',
         sxMatrix_scalar_matrix,
         sxMatrix_set,
         sxMatrix_set',
         sxMatrix_set'',
         sxMatrix_set''',
         sxMatrix_set'''',
         sxMatrix_set''''',
         sxMatrix_setPrecision,
         sxMatrix_setScientific,
         sxMatrix_setWidth,
         sxMatrix_sign,
         sxMatrix_sin,
         sxMatrix_sinh,
         sxMatrix_size,
         sxMatrix_size1,
         sxMatrix_size2,
         sxMatrix_sparse,
         sxMatrix_sparse',
         sxMatrix_sparse'',
         sxMatrix_sparse''',
         sxMatrix_sparsityRef,
         sxMatrix_sqrt,
         sxMatrix_tan,
         sxMatrix_tanh,
         sxMatrix_trans,
         sxMatrix_unary,
         sxMatrix_vector,
         sxMatrix_zeros,
         sxMatrix_zeros',
         sxMatrix_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.Classes.PrintableObject
import Casadi.Wrappers.ForeignToolsInstances ( )
import Casadi.Wrappers.Deleters
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,
                             StdString', CppBool' ) -- StdOstream'
import Casadi.Marshal ( CornerCase(..), Marshal(..) )
import Casadi.WrapReturn ( WrapReturn(..) )

instance Show SXMatrix where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___size1" c_CasADi__Matrix_CasADi__SX___size1
  :: Ptr SXMatrix' -> IO CInt
casADi__Matrix_CasADi__SX___size1
  :: SXMatrix -> IO Int
casADi__Matrix_CasADi__SX___size1 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___size1 x0' >>= wrapReturn

-- classy wrapper
sxMatrix_size1 :: SXMatrixClass a => a -> IO Int
sxMatrix_size1 x = casADi__Matrix_CasADi__SX___size1 (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___size2" c_CasADi__Matrix_CasADi__SX___size2
  :: Ptr SXMatrix' -> IO CInt
casADi__Matrix_CasADi__SX___size2
  :: SXMatrix -> IO Int
casADi__Matrix_CasADi__SX___size2 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___size2 x0' >>= wrapReturn

-- classy wrapper
sxMatrix_size2 :: SXMatrixClass a => a -> IO Int
sxMatrix_size2 x = casADi__Matrix_CasADi__SX___size2 (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___size" c_CasADi__Matrix_CasADi__SX___size
  :: Ptr SXMatrix' -> IO CInt
casADi__Matrix_CasADi__SX___size
  :: SXMatrix -> IO Int
casADi__Matrix_CasADi__SX___size x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___size x0' >>= wrapReturn

-- classy wrapper
sxMatrix_size :: SXMatrixClass a => a -> IO Int
sxMatrix_size x = casADi__Matrix_CasADi__SX___size (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___numel" c_CasADi__Matrix_CasADi__SX___numel
  :: Ptr SXMatrix' -> IO CInt
casADi__Matrix_CasADi__SX___numel
  :: SXMatrix -> IO Int
casADi__Matrix_CasADi__SX___numel x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___numel x0' >>= wrapReturn

-- classy wrapper
sxMatrix_numel :: SXMatrixClass a => a -> IO Int
sxMatrix_numel x = casADi__Matrix_CasADi__SX___numel (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sanityCheck" c_CasADi__Matrix_CasADi__SX___sanityCheck
  :: Ptr SXMatrix' -> Ptr CppBool' -> IO ()
casADi__Matrix_CasADi__SX___sanityCheck
  :: SXMatrix -> Bool -> IO ()
casADi__Matrix_CasADi__SX___sanityCheck x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___sanityCheck x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Check if the dimensions and rowind,col vectors are compatible.
>
>Parameters:
>-----------
>
>complete:  set to true to also check elementwise throws an error as possible
>result
-}
sxMatrix_sanityCheck :: SXMatrixClass a => a -> Bool -> IO ()
sxMatrix_sanityCheck x = casADi__Matrix_CasADi__SX___sanityCheck (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sanityCheck_TIC" c_CasADi__Matrix_CasADi__SX___sanityCheck_TIC
  :: Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___sanityCheck'
  :: SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___sanityCheck' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___sanityCheck_TIC x0' >>= wrapReturn

-- classy wrapper
sxMatrix_sanityCheck' :: SXMatrixClass a => a -> IO ()
sxMatrix_sanityCheck' x = casADi__Matrix_CasADi__SX___sanityCheck' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___vector" c_CasADi__Matrix_CasADi__SX___vector
  :: Ptr SXMatrix' -> IO (Ptr CppBool')
casADi__Matrix_CasADi__SX___vector
  :: SXMatrix -> IO Bool
casADi__Matrix_CasADi__SX___vector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___vector x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>ublas vector
>
>Check type of matrix
-}
sxMatrix_vector :: SXMatrixClass a => a -> IO Bool
sxMatrix_vector x = casADi__Matrix_CasADi__SX___vector (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___at" c_CasADi__Matrix_CasADi__SX___at
  :: Ptr SXMatrix' -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SX___at
  :: SXMatrix -> Int -> IO SX
casADi__Matrix_CasADi__SX___at x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___at x0' x1' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn

-- classy wrapper
{-|
>>  const T& CasADi::Matrix< T >::at(int k) const 
>------------------------------------------------------------------------
>
>Get a non-zero element.
>
>>  T& CasADi::Matrix< T >::at(int k)
>------------------------------------------------------------------------
>
>Access a non-zero element.
-}
sxMatrix_at :: SXMatrixClass a => a -> Int -> IO SX
sxMatrix_at x = casADi__Matrix_CasADi__SX___at (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___elem" c_CasADi__Matrix_CasADi__SX___elem
  :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SX___elem
  :: SXMatrix -> Int -> Int -> IO SX
casADi__Matrix_CasADi__SX___elem x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___elem x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn

-- classy wrapper
{-|
>>  const T & CasADi::Matrix< T >::elem(int i, int j=0) const 
>------------------------------------------------------------------------
>
>get an element
>
>>  T & CasADi::Matrix< T >::elem(int i, int j=0)
>------------------------------------------------------------------------
>
>get a reference to an element
-}
sxMatrix_elem :: SXMatrixClass a => a -> Int -> Int -> IO SX
sxMatrix_elem x = casADi__Matrix_CasADi__SX___elem (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___elem_TIC" c_CasADi__Matrix_CasADi__SX___elem_TIC
  :: Ptr SXMatrix' -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SX___elem'
  :: SXMatrix -> Int -> IO SX
casADi__Matrix_CasADi__SX___elem' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___elem_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn

-- classy wrapper
sxMatrix_elem' :: SXMatrixClass a => a -> Int -> IO SX
sxMatrix_elem' x = casADi__Matrix_CasADi__SX___elem' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___hasNZ" c_CasADi__Matrix_CasADi__SX___hasNZ
  :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr CppBool')
casADi__Matrix_CasADi__SX___hasNZ
  :: SXMatrix -> Int -> Int -> IO Bool
casADi__Matrix_CasADi__SX___hasNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___hasNZ x0' x1' x2' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>Returns true if the matrix has a non-zero at location i,j.
-}
sxMatrix_hasNZ :: SXMatrixClass a => a -> Int -> Int -> IO Bool
sxMatrix_hasNZ x = casADi__Matrix_CasADi__SX___hasNZ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____nonzero__" c_CasADi__Matrix_CasADi__SX_____nonzero__
  :: Ptr SXMatrix' -> IO (Ptr CppBool')
casADi__Matrix_CasADi__SX_____nonzero__
  :: SXMatrix -> IO Bool
casADi__Matrix_CasADi__SX_____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX_____nonzero__ x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>Returns the truth value of a Matrix.
-}
sxMatrix___nonzero__ :: SXMatrixClass a => a -> IO Bool
sxMatrix___nonzero__ x = casADi__Matrix_CasADi__SX_____nonzero__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___append" c_CasADi__Matrix_CasADi__SX___append
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___append
  :: SXMatrix -> SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___append x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___append x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Append a matrix to the end.
-}
sxMatrix_append :: SXMatrixClass a => a -> SXMatrix -> IO ()
sxMatrix_append x = casADi__Matrix_CasADi__SX___append (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___operator_plus" c_CasADi__Matrix_CasADi__SX___operator_plus
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___operator_plus
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___operator_plus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___operator_plus x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_operator_plus :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_operator_plus x = casADi__Matrix_CasADi__SX___operator_plus (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___operator_minus" c_CasADi__Matrix_CasADi__SX___operator_minus
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___operator_minus
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___operator_minus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___operator_minus x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_operator_minus :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_operator_minus x = casADi__Matrix_CasADi__SX___operator_minus (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___binary" c_CasADi__Matrix_CasADi__SX___binary
  :: CInt -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___binary
  :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___binary x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___binary x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
sxMatrix_binary :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix
sxMatrix_binary = casADi__Matrix_CasADi__SX___binary


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___unary" c_CasADi__Matrix_CasADi__SX___unary
  :: CInt -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___unary
  :: Int -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___unary x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___unary x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
sxMatrix_unary :: Int -> SXMatrix -> IO SXMatrix
sxMatrix_unary = casADi__Matrix_CasADi__SX___unary


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___scalar_matrix" c_CasADi__Matrix_CasADi__SX___scalar_matrix
  :: CInt -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___scalar_matrix
  :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___scalar_matrix x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___scalar_matrix x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
sxMatrix_scalar_matrix :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix
sxMatrix_scalar_matrix = casADi__Matrix_CasADi__SX___scalar_matrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___matrix_scalar" c_CasADi__Matrix_CasADi__SX___matrix_scalar
  :: CInt -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___matrix_scalar
  :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___matrix_scalar x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___matrix_scalar x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
sxMatrix_matrix_scalar :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix
sxMatrix_matrix_scalar = casADi__Matrix_CasADi__SX___matrix_scalar


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___matrix_matrix" c_CasADi__Matrix_CasADi__SX___matrix_matrix
  :: CInt -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___matrix_matrix
  :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___matrix_matrix x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___matrix_matrix x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
sxMatrix_matrix_matrix :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix
sxMatrix_matrix_matrix = casADi__Matrix_CasADi__SX___matrix_matrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____add__" c_CasADi__Matrix_CasADi__SX_____add__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____add__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____add__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____add__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___add__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___add__ x = casADi__Matrix_CasADi__SX_____add__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____sub__" c_CasADi__Matrix_CasADi__SX_____sub__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____sub__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____sub__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____sub__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___sub__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___sub__ x = casADi__Matrix_CasADi__SX_____sub__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____mul__" c_CasADi__Matrix_CasADi__SX_____mul__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____mul__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____mul__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____mul__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___mul__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___mul__ x = casADi__Matrix_CasADi__SX_____mul__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____div__" c_CasADi__Matrix_CasADi__SX_____div__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____div__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____div__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____div__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___div__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___div__ x = casADi__Matrix_CasADi__SX_____div__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____lt__" c_CasADi__Matrix_CasADi__SX_____lt__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____lt__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____lt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____lt__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___lt__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___lt__ x = casADi__Matrix_CasADi__SX_____lt__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____le__" c_CasADi__Matrix_CasADi__SX_____le__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____le__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____le__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____le__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___le__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___le__ x = casADi__Matrix_CasADi__SX_____le__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____eq__" c_CasADi__Matrix_CasADi__SX_____eq__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____eq__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____eq__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____eq__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___eq__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___eq__ x = casADi__Matrix_CasADi__SX_____eq__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____ne__" c_CasADi__Matrix_CasADi__SX_____ne__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____ne__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____ne__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____ne__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___ne__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___ne__ x = casADi__Matrix_CasADi__SX_____ne__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____truediv__" c_CasADi__Matrix_CasADi__SX_____truediv__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____truediv__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____truediv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____truediv__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___truediv__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___truediv__ x = casADi__Matrix_CasADi__SX_____truediv__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____pow__" c_CasADi__Matrix_CasADi__SX_____pow__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____pow__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____pow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____pow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___pow__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___pow__ x = casADi__Matrix_CasADi__SX_____pow__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____constpow__" c_CasADi__Matrix_CasADi__SX_____constpow__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____constpow__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____constpow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____constpow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___constpow__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___constpow__ x = casADi__Matrix_CasADi__SX_____constpow__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____mpower__" c_CasADi__Matrix_CasADi__SX_____mpower__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____mpower__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____mpower__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____mpower__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___mpower__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___mpower__ x = casADi__Matrix_CasADi__SX_____mpower__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____mrdivide__" c_CasADi__Matrix_CasADi__SX_____mrdivide__
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX_____mrdivide__
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX_____mrdivide__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX_____mrdivide__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
sxMatrix___mrdivide__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix___mrdivide__ x = casADi__Matrix_CasADi__SX_____mrdivide__ (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_full" c_CasADi__Matrix_CasADi__SX___mul_full
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr CRSSparsity' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___mul_full
  :: SXMatrix -> SXMatrix -> CRSSparsity -> IO SXMatrix
casADi__Matrix_CasADi__SX___mul_full x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___mul_full x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Matrix-matrix product.
-}
sxMatrix_mul_full :: SXMatrixClass a => a -> SXMatrix -> CRSSparsity -> IO SXMatrix
sxMatrix_mul_full x = casADi__Matrix_CasADi__SX___mul_full (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_full_TIC" c_CasADi__Matrix_CasADi__SX___mul_full_TIC
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___mul_full'
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___mul_full' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___mul_full_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_mul_full' :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_mul_full' x = casADi__Matrix_CasADi__SX___mul_full' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul" c_CasADi__Matrix_CasADi__SX___mul
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr CRSSparsity' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___mul
  :: SXMatrix -> SXMatrix -> CRSSparsity -> IO SXMatrix
casADi__Matrix_CasADi__SX___mul x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___mul x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Matrix-matrix product.
-}
sxMatrix_mul :: SXMatrixClass a => a -> SXMatrix -> CRSSparsity -> IO SXMatrix
sxMatrix_mul x = casADi__Matrix_CasADi__SX___mul (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_TIC" c_CasADi__Matrix_CasADi__SX___mul_TIC
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___mul'
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___mul' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___mul_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_mul' :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_mul' x = casADi__Matrix_CasADi__SX___mul' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_nn" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nn
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_nn
  :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_nn x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_mul_no_alloc_nn :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()
sxMatrix_mul_no_alloc_nn = casADi__Matrix_CasADi__SX___mul_no_alloc_nn


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_nt" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nt
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_nt
  :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_nt x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_mul_no_alloc_nt :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()
sxMatrix_mul_no_alloc_nt = casADi__Matrix_CasADi__SX___mul_no_alloc_nt


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_tn" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_tn
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_tn
  :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_tn x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_mul_no_alloc_tn :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()
sxMatrix_mul_no_alloc_tn = casADi__Matrix_CasADi__SX___mul_no_alloc_tn


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC
  :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_nn'
  :: SXMatrix -> Vector SX -> Vector SX -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_nn' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_mul_no_alloc_nn' :: SXMatrix -> Vector SX -> Vector SX -> IO ()
sxMatrix_mul_no_alloc_nn' = casADi__Matrix_CasADi__SX___mul_no_alloc_nn'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC
  :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_tn'
  :: SXMatrix -> Vector SX -> Vector SX -> IO ()
casADi__Matrix_CasADi__SX___mul_no_alloc_tn' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_mul_no_alloc_tn' :: SXMatrix -> Vector SX -> Vector SX -> IO ()
sxMatrix_mul_no_alloc_tn' = casADi__Matrix_CasADi__SX___mul_no_alloc_tn'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___quad_form" c_CasADi__Matrix_CasADi__SX___quad_form
  :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SX')
casADi__Matrix_CasADi__SX___quad_form
  :: SXMatrix -> Vector SX -> IO SX
casADi__Matrix_CasADi__SX___quad_form x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___quad_form x0' x1' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn

-- classy wrapper
sxMatrix_quad_form :: SXMatrix -> Vector SX -> IO SX
sxMatrix_quad_form = casADi__Matrix_CasADi__SX___quad_form


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___trans" c_CasADi__Matrix_CasADi__SX___trans
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___trans
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___trans x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___trans x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Matrix transpose.
-}
sxMatrix_trans :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_trans x = casADi__Matrix_CasADi__SX___trans (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sin" c_CasADi__Matrix_CasADi__SX___sin
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___sin
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___sin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___sin x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_sin :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_sin x = casADi__Matrix_CasADi__SX___sin (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___cos" c_CasADi__Matrix_CasADi__SX___cos
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___cos
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___cos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___cos x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_cos :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_cos x = casADi__Matrix_CasADi__SX___cos (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___tan" c_CasADi__Matrix_CasADi__SX___tan
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___tan
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___tan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___tan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_tan :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_tan x = casADi__Matrix_CasADi__SX___tan (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arcsin" c_CasADi__Matrix_CasADi__SX___arcsin
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___arcsin
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___arcsin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___arcsin x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_arcsin :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_arcsin x = casADi__Matrix_CasADi__SX___arcsin (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arccos" c_CasADi__Matrix_CasADi__SX___arccos
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___arccos
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___arccos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___arccos x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_arccos :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_arccos x = casADi__Matrix_CasADi__SX___arccos (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arctan" c_CasADi__Matrix_CasADi__SX___arctan
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___arctan
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___arctan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___arctan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_arctan :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_arctan x = casADi__Matrix_CasADi__SX___arctan (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___exp" c_CasADi__Matrix_CasADi__SX___exp
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___exp
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___exp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___exp x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_exp :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_exp x = casADi__Matrix_CasADi__SX___exp (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___log" c_CasADi__Matrix_CasADi__SX___log
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___log
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___log x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___log x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_log :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_log x = casADi__Matrix_CasADi__SX___log (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sqrt" c_CasADi__Matrix_CasADi__SX___sqrt
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___sqrt
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___sqrt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___sqrt x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_sqrt :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_sqrt x = casADi__Matrix_CasADi__SX___sqrt (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___floor" c_CasADi__Matrix_CasADi__SX___floor
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___floor
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___floor x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___floor x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_floor :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_floor x = casADi__Matrix_CasADi__SX___floor (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___ceil" c_CasADi__Matrix_CasADi__SX___ceil
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___ceil
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___ceil x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___ceil x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_ceil :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_ceil x = casADi__Matrix_CasADi__SX___ceil (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___fabs" c_CasADi__Matrix_CasADi__SX___fabs
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___fabs
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___fabs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___fabs x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_fabs :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_fabs x = casADi__Matrix_CasADi__SX___fabs (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sign" c_CasADi__Matrix_CasADi__SX___sign
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___sign
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___sign x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___sign x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_sign :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_sign x = casADi__Matrix_CasADi__SX___sign (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___erfinv" c_CasADi__Matrix_CasADi__SX___erfinv
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___erfinv
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___erfinv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___erfinv x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_erfinv :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_erfinv x = casADi__Matrix_CasADi__SX___erfinv (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___fmin" c_CasADi__Matrix_CasADi__SX___fmin
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___fmin
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___fmin x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___fmin x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_fmin :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_fmin x = casADi__Matrix_CasADi__SX___fmin (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___fmax" c_CasADi__Matrix_CasADi__SX___fmax
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___fmax
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___fmax x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___fmax x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_fmax :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_fmax x = casADi__Matrix_CasADi__SX___fmax (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___erf" c_CasADi__Matrix_CasADi__SX___erf
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___erf
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___erf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___erf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_erf :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_erf x = casADi__Matrix_CasADi__SX___erf (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sinh" c_CasADi__Matrix_CasADi__SX___sinh
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___sinh
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___sinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___sinh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_sinh :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_sinh x = casADi__Matrix_CasADi__SX___sinh (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___cosh" c_CasADi__Matrix_CasADi__SX___cosh
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___cosh
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___cosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___cosh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_cosh :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_cosh x = casADi__Matrix_CasADi__SX___cosh (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___tanh" c_CasADi__Matrix_CasADi__SX___tanh
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___tanh
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___tanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___tanh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_tanh :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_tanh x = casADi__Matrix_CasADi__SX___tanh (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arcsinh" c_CasADi__Matrix_CasADi__SX___arcsinh
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___arcsinh
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___arcsinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___arcsinh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_arcsinh :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_arcsinh x = casADi__Matrix_CasADi__SX___arcsinh (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arccosh" c_CasADi__Matrix_CasADi__SX___arccosh
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___arccosh
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___arccosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___arccosh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_arccosh :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_arccosh x = casADi__Matrix_CasADi__SX___arccosh (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arctanh" c_CasADi__Matrix_CasADi__SX___arctanh
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___arctanh
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___arctanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___arctanh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_arctanh :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_arctanh x = casADi__Matrix_CasADi__SX___arctanh (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arctan2" c_CasADi__Matrix_CasADi__SX___arctan2
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___arctan2
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___arctan2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___arctan2 x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_arctan2 :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_arctan2 x = casADi__Matrix_CasADi__SX___arctan2 (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___log10" c_CasADi__Matrix_CasADi__SX___log10
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___log10
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___log10 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___log10 x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_log10 :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_log10 x = casADi__Matrix_CasADi__SX___log10 (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printme" c_CasADi__Matrix_CasADi__SX___printme
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___printme
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___printme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___printme x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_printme :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_printme x = casADi__Matrix_CasADi__SX___printme (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___logic_not" c_CasADi__Matrix_CasADi__SX___logic_not
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___logic_not
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___logic_not x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___logic_not x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_logic_not :: SXMatrixClass a => a -> IO SXMatrix
sxMatrix_logic_not x = casADi__Matrix_CasADi__SX___logic_not (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___logic_and" c_CasADi__Matrix_CasADi__SX___logic_and
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___logic_and
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___logic_and x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___logic_and x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_logic_and :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_logic_and x = casADi__Matrix_CasADi__SX___logic_and (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___logic_or" c_CasADi__Matrix_CasADi__SX___logic_or
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___logic_or
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___logic_or x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___logic_or x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_logic_or :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_logic_or x = casADi__Matrix_CasADi__SX___logic_or (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___if_else_zero" c_CasADi__Matrix_CasADi__SX___if_else_zero
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___if_else_zero
  :: SXMatrix -> SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___if_else_zero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___if_else_zero x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sxMatrix_if_else_zero :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix
sxMatrix_if_else_zero x = casADi__Matrix_CasADi__SX___if_else_zero (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___className" c_CasADi__Matrix_CasADi__SX___className
  :: IO (Ptr StdString')
casADi__Matrix_CasADi__SX___className
  :: IO String
casADi__Matrix_CasADi__SX___className  =
  c_CasADi__Matrix_CasADi__SX___className  >>= (newForeignPtr c_delete_std__string) >>= wrapReturn

-- classy wrapper
{-|
>Printing.
-}
sxMatrix_className :: IO String
sxMatrix_className = casADi__Matrix_CasADi__SX___className


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printScalar_TIC" c_CasADi__Matrix_CasADi__SX___printScalar_TIC
  :: Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___printScalar'
  :: SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___printScalar' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___printScalar_TIC x0' >>= wrapReturn

-- classy wrapper
sxMatrix_printScalar' :: SXMatrixClass a => a -> IO ()
sxMatrix_printScalar' x = casADi__Matrix_CasADi__SX___printScalar' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printVector_TIC" c_CasADi__Matrix_CasADi__SX___printVector_TIC
  :: Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___printVector'
  :: SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___printVector' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___printVector_TIC x0' >>= wrapReturn

-- classy wrapper
sxMatrix_printVector' :: SXMatrixClass a => a -> IO ()
sxMatrix_printVector' x = casADi__Matrix_CasADi__SX___printVector' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printMatrix_TIC" c_CasADi__Matrix_CasADi__SX___printMatrix_TIC
  :: Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___printMatrix'
  :: SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___printMatrix' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___printMatrix_TIC x0' >>= wrapReturn

-- classy wrapper
sxMatrix_printMatrix' :: SXMatrixClass a => a -> IO ()
sxMatrix_printMatrix' x = casADi__Matrix_CasADi__SX___printMatrix' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printSparse_TIC" c_CasADi__Matrix_CasADi__SX___printSparse_TIC
  :: Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___printSparse'
  :: SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___printSparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___printSparse_TIC x0' >>= wrapReturn

-- classy wrapper
sxMatrix_printSparse' :: SXMatrixClass a => a -> IO ()
sxMatrix_printSparse' x = casADi__Matrix_CasADi__SX___printSparse' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printDense_TIC" c_CasADi__Matrix_CasADi__SX___printDense_TIC
  :: Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___printDense'
  :: SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___printDense' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___printDense_TIC x0' >>= wrapReturn

-- classy wrapper
sxMatrix_printDense' :: SXMatrixClass a => a -> IO ()
sxMatrix_printDense' x = casADi__Matrix_CasADi__SX___printDense' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___col" c_CasADi__Matrix_CasADi__SX___col
  :: Ptr SXMatrix' -> CInt -> IO CInt
casADi__Matrix_CasADi__SX___col
  :: SXMatrix -> Int -> IO Int
casADi__Matrix_CasADi__SX___col x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___col x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_col :: SXMatrixClass a => a -> Int -> IO Int
sxMatrix_col x = casADi__Matrix_CasADi__SX___col (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___rowind" c_CasADi__Matrix_CasADi__SX___rowind
  :: Ptr SXMatrix' -> CInt -> IO CInt
casADi__Matrix_CasADi__SX___rowind
  :: SXMatrix -> Int -> IO Int
casADi__Matrix_CasADi__SX___rowind x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___rowind x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_rowind :: SXMatrixClass a => a -> Int -> IO Int
sxMatrix_rowind x = casADi__Matrix_CasADi__SX___rowind (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___clear" c_CasADi__Matrix_CasADi__SX___clear
  :: Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___clear
  :: SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___clear x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___clear x0' >>= wrapReturn

-- classy wrapper
sxMatrix_clear :: SXMatrixClass a => a -> IO ()
sxMatrix_clear x = casADi__Matrix_CasADi__SX___clear (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___resize" c_CasADi__Matrix_CasADi__SX___resize
  :: Ptr SXMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_CasADi__SX___resize
  :: SXMatrix -> Int -> Int -> IO ()
casADi__Matrix_CasADi__SX___resize x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___resize x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_resize :: SXMatrixClass a => a -> Int -> Int -> IO ()
sxMatrix_resize x = casADi__Matrix_CasADi__SX___resize (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___reserve" c_CasADi__Matrix_CasADi__SX___reserve
  :: Ptr SXMatrix' -> CInt -> IO ()
casADi__Matrix_CasADi__SX___reserve
  :: SXMatrix -> Int -> IO ()
casADi__Matrix_CasADi__SX___reserve x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___reserve x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_reserve :: SXMatrixClass a => a -> Int -> IO ()
sxMatrix_reserve x = casADi__Matrix_CasADi__SX___reserve (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___reserve_TIC" c_CasADi__Matrix_CasADi__SX___reserve_TIC
  :: Ptr SXMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_CasADi__SX___reserve'
  :: SXMatrix -> Int -> Int -> IO ()
casADi__Matrix_CasADi__SX___reserve' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___reserve_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_reserve' :: SXMatrixClass a => a -> Int -> Int -> IO ()
sxMatrix_reserve' x = casADi__Matrix_CasADi__SX___reserve' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___erase" c_CasADi__Matrix_CasADi__SX___erase
  :: Ptr SXMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SX___erase
  :: SXMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_CasADi__SX___erase x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___erase x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Erase a submatrix Erase rows and/or columns of a matrix.
-}
sxMatrix_erase :: SXMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
sxMatrix_erase x = casADi__Matrix_CasADi__SX___erase (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___remove" c_CasADi__Matrix_CasADi__SX___remove
  :: Ptr SXMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SX___remove
  :: SXMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_CasADi__SX___remove x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___remove x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Remove rows or columns Rremove/delete rows and/or columns of a matrix.
-}
sxMatrix_remove :: SXMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
sxMatrix_remove x = casADi__Matrix_CasADi__SX___remove (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___enlarge" c_CasADi__Matrix_CasADi__SX___enlarge
  :: Ptr SXMatrix' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SX___enlarge
  :: SXMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_CasADi__SX___enlarge x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_CasADi__SX___enlarge x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
{-|
>Enlarge matrix Make the matrix larger by inserting empty rows and columns,
>keeping the existing non-zeros.
-}
sxMatrix_enlarge :: SXMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
sxMatrix_enlarge x = casADi__Matrix_CasADi__SX___enlarge (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___data" c_CasADi__Matrix_CasADi__SX___data
  :: Ptr SXMatrix' -> IO (Ptr (CppVec (Ptr SX')))
casADi__Matrix_CasADi__SX___data
  :: SXMatrix -> IO (Vector SX)
casADi__Matrix_CasADi__SX___data x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___data x0' >>= (newForeignPtr c_delete_std__vector_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>>  std::vector< T > & CasADi::Matrix< T >::data()
>------------------------------------------------------------------------
>
>Access the non-zero elements.
>
>>  const std::vector< T > & CasADi::Matrix< T >::data() const 
>------------------------------------------------------------------------
>
>Const access the non-zero elements.
-}
sxMatrix_data :: SXMatrixClass a => a -> IO (Vector SX)
sxMatrix_data x = casADi__Matrix_CasADi__SX___data (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparsityRef" c_CasADi__Matrix_CasADi__SX___sparsityRef
  :: Ptr SXMatrix' -> IO (Ptr CRSSparsity')
casADi__Matrix_CasADi__SX___sparsityRef
  :: SXMatrix -> IO CRSSparsity
casADi__Matrix_CasADi__SX___sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___sparsityRef x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
{-|
>Access the sparsity, make a copy if there are multiple references to it.
-}
sxMatrix_sparsityRef :: SXMatrixClass a => a -> IO CRSSparsity
sxMatrix_sparsityRef x = casADi__Matrix_CasADi__SX___sparsityRef (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set" c_CasADi__Matrix_CasADi__SX___set
  :: Ptr SXMatrix' -> Ptr SX' -> CInt -> IO ()
casADi__Matrix_CasADi__SX___set
  :: SXMatrix -> SX -> Sparsity -> IO ()
casADi__Matrix_CasADi__SX___set x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___set x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< T >::set(T val, Sparsity sp=SPARSE)
>------------------------------------------------------------------------
>
>Set the non-zero elements, scalar.
>
>>  void CasADi::Matrix< T >::set(const std::vector< T > &val, Sparsity sp=SPARSE)
>------------------------------------------------------------------------
>
>Set the non-zero elements, vector.
>
>>  void CasADi::Matrix< T >::set(const Matrix< T > &val, Sparsity sp=SPARSE)
>------------------------------------------------------------------------
>
>Set the non-zero elements, Matrix.
>
>>  void CasADi::Matrix< T >::set(const T *val, Sparsity sp=SPARSE)
>------------------------------------------------------------------------
>
>Legacy - use setArray instead.
-}
sxMatrix_set :: SXMatrixClass a => a -> SX -> Sparsity -> IO ()
sxMatrix_set x = casADi__Matrix_CasADi__SX___set (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC
  :: Ptr SXMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SX___set'
  :: SXMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SX___set' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___set_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_set' :: SXMatrixClass a => a -> SX -> IO ()
sxMatrix_set' x = casADi__Matrix_CasADi__SX___set' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get" c_CasADi__Matrix_CasADi__SX___get
  :: Ptr SXMatrix' -> Ptr SX' -> CInt -> IO ()
casADi__Matrix_CasADi__SX___get
  :: SXMatrix -> SX -> Sparsity -> IO ()
casADi__Matrix_CasADi__SX___get x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___get x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< T >::get(T &val, Sparsity sp=SPARSE) const 
>------------------------------------------------------------------------
>
>Get the non-zero elements, scalar.
>
>>  void CasADi::Matrix< T >::get(std::vector< T > &val, Sparsity sp=SPARSE) const 
>------------------------------------------------------------------------
>
>Get the non-zero elements, vector.
>
>>  void CasADi::Matrix< T >::get(Matrix< T > &val, Sparsity sp=SPARSE) const 
>------------------------------------------------------------------------
>
>Get the non-zero elements, Matrix.
>
>>  void CasADi::Matrix< T >::get(T *val, Sparsity sp=SPARSE) const 
>------------------------------------------------------------------------
>
>Legacy - use getArray instead.
-}
sxMatrix_get :: SXMatrixClass a => a -> SX -> Sparsity -> IO ()
sxMatrix_get x = casADi__Matrix_CasADi__SX___get (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC
  :: Ptr SXMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SX___get'
  :: SXMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SX___get' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___get_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_get' :: SXMatrixClass a => a -> SX -> IO ()
sxMatrix_get' x = casADi__Matrix_CasADi__SX___get' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC_TIC
  :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> CInt -> IO ()
casADi__Matrix_CasADi__SX___set''
  :: SXMatrix -> Vector SX -> Sparsity -> IO ()
casADi__Matrix_CasADi__SX___set'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___set_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_set'' :: SXMatrixClass a => a -> Vector SX -> Sparsity -> IO ()
sxMatrix_set'' x = casADi__Matrix_CasADi__SX___set'' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC
  :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> IO ()
casADi__Matrix_CasADi__SX___set'''
  :: SXMatrix -> Vector SX -> IO ()
casADi__Matrix_CasADi__SX___set''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_set''' :: SXMatrixClass a => a -> Vector SX -> IO ()
sxMatrix_set''' x = casADi__Matrix_CasADi__SX___set''' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC_TIC
  :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> CInt -> IO ()
casADi__Matrix_CasADi__SX___get''
  :: SXMatrix -> Vector SX -> Sparsity -> IO ()
casADi__Matrix_CasADi__SX___get'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___get_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_get'' :: SXMatrixClass a => a -> Vector SX -> Sparsity -> IO ()
sxMatrix_get'' x = casADi__Matrix_CasADi__SX___get'' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC
  :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> IO ()
casADi__Matrix_CasADi__SX___get'''
  :: SXMatrix -> Vector SX -> IO ()
casADi__Matrix_CasADi__SX___get''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_get''' :: SXMatrixClass a => a -> Vector SX -> IO ()
sxMatrix_get''' x = casADi__Matrix_CasADi__SX___get''' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> IO ()
casADi__Matrix_CasADi__SX___set''''
  :: SXMatrix -> SXMatrix -> Sparsity -> IO ()
casADi__Matrix_CasADi__SX___set'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_set'''' :: SXMatrixClass a => a -> SXMatrix -> Sparsity -> IO ()
sxMatrix_set'''' x = casADi__Matrix_CasADi__SX___set'''' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___set'''''
  :: SXMatrix -> SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___set''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_set''''' :: SXMatrixClass a => a -> SXMatrix -> IO ()
sxMatrix_set''''' x = casADi__Matrix_CasADi__SX___set''''' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> IO ()
casADi__Matrix_CasADi__SX___get''''
  :: SXMatrix -> SXMatrix -> Sparsity -> IO ()
casADi__Matrix_CasADi__SX___get'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxMatrix_get'''' :: SXMatrixClass a => a -> SXMatrix -> Sparsity -> IO ()
sxMatrix_get'''' x = casADi__Matrix_CasADi__SX___get'''' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()
casADi__Matrix_CasADi__SX___get'''''
  :: SXMatrix -> SXMatrix -> IO ()
casADi__Matrix_CasADi__SX___get''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxMatrix_get''''' :: SXMatrixClass a => a -> SXMatrix -> IO ()
sxMatrix_get''''' x = casADi__Matrix_CasADi__SX___get''''' (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparse" c_CasADi__Matrix_CasADi__SX___sparse
  :: CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___sparse
  :: Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___sparse x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___sparse x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>>  Matrix< T > CasADi::Matrix< T >::sparse(int nrow, int ncol=1)
>
>>  Matrix< T > CasADi::Matrix< T >::sparse(const std::pair< int, int > &nm)
>------------------------------------------------------------------------
>
>create a sparse matrix with all zeros
>
>>  Matrix< T > CasADi::Matrix< T >::sparse(const std::vector< int > &row, const std::vector< int > &col, const std::vector< T > &d, int n, int m)
>
>>  Matrix< T > CasADi::Matrix< T >::sparse(const std::vector< int > &row, const std::vector< int > &col, const std::vector< T > &d, const std::pair< int, int > &nm)
>------------------------------------------------------------------------
>
>Construct a sparse matrix from triplet form.
-}
sxMatrix_sparse :: Int -> Int -> IO SXMatrix
sxMatrix_sparse = casADi__Matrix_CasADi__SX___sparse


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparse_TIC" c_CasADi__Matrix_CasADi__SX___sparse_TIC
  :: CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___sparse'
  :: Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___sparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___sparse_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_sparse' :: Int -> IO SXMatrix
sxMatrix_sparse' = casADi__Matrix_CasADi__SX___sparse'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparse_TIC_TIC" c_CasADi__Matrix_CasADi__SX___sparse_TIC_TIC
  :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___sparse''
  :: Vector Int -> Vector Int -> Vector SX -> IO SXMatrix
casADi__Matrix_CasADi__SX___sparse'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___sparse_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_sparse'' :: Vector Int -> Vector Int -> Vector SX -> IO SXMatrix
sxMatrix_sparse'' = casADi__Matrix_CasADi__SX___sparse''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___sparse'''
  :: Vector Int -> Vector Int -> Vector SX -> Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___sparse''' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_sparse''' :: Vector Int -> Vector Int -> Vector SX -> Int -> Int -> IO SXMatrix
sxMatrix_sparse''' = casADi__Matrix_CasADi__SX___sparse'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___zeros" c_CasADi__Matrix_CasADi__SX___zeros
  :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___zeros
  :: CRSSparsity -> IO SXMatrix
casADi__Matrix_CasADi__SX___zeros x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___zeros x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>create a dense matrix with all zeros
-}
sxMatrix_zeros :: CRSSparsity -> IO SXMatrix
sxMatrix_zeros = casADi__Matrix_CasADi__SX___zeros


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___zeros_TIC" c_CasADi__Matrix_CasADi__SX___zeros_TIC
  :: CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___zeros'
  :: Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___zeros' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___zeros_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_zeros' :: Int -> Int -> IO SXMatrix
sxMatrix_zeros' = casADi__Matrix_CasADi__SX___zeros'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___zeros_TIC_TIC" c_CasADi__Matrix_CasADi__SX___zeros_TIC_TIC
  :: CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___zeros''
  :: Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___zeros'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___zeros_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_zeros'' :: Int -> IO SXMatrix
sxMatrix_zeros'' = casADi__Matrix_CasADi__SX___zeros''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___ones" c_CasADi__Matrix_CasADi__SX___ones
  :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___ones
  :: CRSSparsity -> IO SXMatrix
casADi__Matrix_CasADi__SX___ones x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___ones x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all ones
-}
sxMatrix_ones :: CRSSparsity -> IO SXMatrix
sxMatrix_ones = casADi__Matrix_CasADi__SX___ones


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___ones_TIC" c_CasADi__Matrix_CasADi__SX___ones_TIC
  :: CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___ones'
  :: Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___ones' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___ones_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_ones' :: Int -> Int -> IO SXMatrix
sxMatrix_ones' = casADi__Matrix_CasADi__SX___ones'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___ones_TIC_TIC" c_CasADi__Matrix_CasADi__SX___ones_TIC_TIC
  :: CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___ones''
  :: Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___ones'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___ones_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_ones'' :: Int -> IO SXMatrix
sxMatrix_ones'' = casADi__Matrix_CasADi__SX___ones''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___inf" c_CasADi__Matrix_CasADi__SX___inf
  :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___inf
  :: CRSSparsity -> IO SXMatrix
casADi__Matrix_CasADi__SX___inf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___inf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all inf
-}
sxMatrix_inf :: CRSSparsity -> IO SXMatrix
sxMatrix_inf = casADi__Matrix_CasADi__SX___inf


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___inf_TIC" c_CasADi__Matrix_CasADi__SX___inf_TIC
  :: CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___inf'
  :: Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___inf' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___inf_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_inf' :: Int -> Int -> IO SXMatrix
sxMatrix_inf' = casADi__Matrix_CasADi__SX___inf'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___inf_TIC_TIC" c_CasADi__Matrix_CasADi__SX___inf_TIC_TIC
  :: CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___inf''
  :: Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___inf'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___inf_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_inf'' :: Int -> IO SXMatrix
sxMatrix_inf'' = casADi__Matrix_CasADi__SX___inf''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC
  :: IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___inf'''
  :: IO SXMatrix
casADi__Matrix_CasADi__SX___inf'''  =
  c_CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC  >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_inf''' :: IO SXMatrix
sxMatrix_inf''' = casADi__Matrix_CasADi__SX___inf'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___nan" c_CasADi__Matrix_CasADi__SX___nan
  :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___nan
  :: CRSSparsity -> IO SXMatrix
casADi__Matrix_CasADi__SX___nan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___nan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all nan
-}
sxMatrix_nan :: CRSSparsity -> IO SXMatrix
sxMatrix_nan = casADi__Matrix_CasADi__SX___nan


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___nan_TIC" c_CasADi__Matrix_CasADi__SX___nan_TIC
  :: CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___nan'
  :: Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___nan' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___nan_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_nan' :: Int -> Int -> IO SXMatrix
sxMatrix_nan' = casADi__Matrix_CasADi__SX___nan'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___nan_TIC_TIC" c_CasADi__Matrix_CasADi__SX___nan_TIC_TIC
  :: CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___nan''
  :: Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___nan'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___nan_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_nan'' :: Int -> IO SXMatrix
sxMatrix_nan'' = casADi__Matrix_CasADi__SX___nan''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC
  :: IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___nan'''
  :: IO SXMatrix
casADi__Matrix_CasADi__SX___nan'''  =
  c_CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC  >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_nan''' :: IO SXMatrix
sxMatrix_nan''' = casADi__Matrix_CasADi__SX___nan'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___repmat" c_CasADi__Matrix_CasADi__SX___repmat
  :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___repmat
  :: SXMatrix -> Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___repmat x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___repmat x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix by repeating an existing matrix
-}
sxMatrix_repmat :: SXMatrix -> Int -> Int -> IO SXMatrix
sxMatrix_repmat = casADi__Matrix_CasADi__SX___repmat


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___repmat_TIC" c_CasADi__Matrix_CasADi__SX___repmat_TIC
  :: Ptr SXMatrix' -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___repmat'
  :: SXMatrix -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___repmat' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___repmat_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_repmat' :: SXMatrix -> Int -> IO SXMatrix
sxMatrix_repmat' = casADi__Matrix_CasADi__SX___repmat'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___eye" c_CasADi__Matrix_CasADi__SX___eye
  :: CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___eye
  :: Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___eye x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___eye x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix_eye :: Int -> IO SXMatrix
sxMatrix_eye = casADi__Matrix_CasADi__SX___eye


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___isNull" c_CasADi__Matrix_CasADi__SX___isNull
  :: Ptr SXMatrix' -> IO (Ptr CppBool')
casADi__Matrix_CasADi__SX___isNull
  :: SXMatrix -> IO Bool
casADi__Matrix_CasADi__SX___isNull x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___isNull x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>The following function is used to ensure similarity to MX, which is
>reference counted.
-}
sxMatrix_isNull :: SXMatrixClass a => a -> IO Bool
sxMatrix_isNull x = casADi__Matrix_CasADi__SX___isNull (castSXMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___setPrecision" c_CasADi__Matrix_CasADi__SX___setPrecision
  :: CInt -> IO ()
casADi__Matrix_CasADi__SX___setPrecision
  :: Int -> IO ()
casADi__Matrix_CasADi__SX___setPrecision x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___setPrecision x0' >>= wrapReturn

-- classy wrapper
{-|
>Set the 'precision, width & scientific' used in printing and serializing to
>streams.
-}
sxMatrix_setPrecision :: Int -> IO ()
sxMatrix_setPrecision = casADi__Matrix_CasADi__SX___setPrecision


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___setWidth" c_CasADi__Matrix_CasADi__SX___setWidth
  :: CInt -> IO ()
casADi__Matrix_CasADi__SX___setWidth
  :: Int -> IO ()
casADi__Matrix_CasADi__SX___setWidth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___setWidth x0' >>= wrapReturn

-- classy wrapper
{-|
>Set the 'precision, width & scientific' used in printing and serializing to
>streams.
-}
sxMatrix_setWidth :: Int -> IO ()
sxMatrix_setWidth = casADi__Matrix_CasADi__SX___setWidth


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___setScientific" c_CasADi__Matrix_CasADi__SX___setScientific
  :: Ptr CppBool' -> IO ()
casADi__Matrix_CasADi__SX___setScientific
  :: Bool -> IO ()
casADi__Matrix_CasADi__SX___setScientific x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___setScientific x0' >>= wrapReturn

-- classy wrapper
{-|
>Set the 'precision, width & scientific' used in printing and serializing to
>streams.
-}
sxMatrix_setScientific :: Bool -> IO ()
sxMatrix_setScientific = casADi__Matrix_CasADi__SX___setScientific


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix" c_CasADi__Matrix_CasADi__SX___SXMatrix
  :: IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix
  :: IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix  =
  c_CasADi__Matrix_CasADi__SX___SXMatrix  >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::Matrix< T >::Matrix()
>------------------------------------------------------------------------
>
>constructors
>
>empty 0-by-0 matrix constructor
>
>>  CasADi::Matrix< T >::Matrix(const Matrix< T > &m)
>------------------------------------------------------------------------
>
>Copy constructor.
>
>>  CasADi::Matrix< T >::Matrix(int n, int m)
>------------------------------------------------------------------------
>
>empty n-by-m matrix constructor
>
>>  CasADi::Matrix< T >::Matrix(int n, int m, const T &val)
>------------------------------------------------------------------------
>
>dense n-by-m matrix filled with val constructor
>
>>  CasADi::Matrix< T >::Matrix(int n, int m, const std::vector< int > &col, const std::vector< int > &rowind, const std::vector< T > &d=std::vector< T >())
>------------------------------------------------------------------------
>
>sparse n-by-m matrix filled with given sparsity
>
>>  CasADi::Matrix< T >::Matrix(const std::vector< std::vector< T > > &m)
>------------------------------------------------------------------------
>
>dense matrix constructor with data given as vector of vectors
>
>>  CasADi::Matrix< T >::Matrix(const CRSSparsity &sparsity, const T &val=0)
>------------------------------------------------------------------------
>
>sparse matrix with a given sparsity
>
>>  CasADi::Matrix< T >::Matrix(const CRSSparsity &sparsity, const std::vector< T > &d)
>------------------------------------------------------------------------
>
>sparse matrix with a given sparsity and non-zero elements.
>
>>  CasADi::Matrix< T >::Matrix(double val)
>------------------------------------------------------------------------
>
>This constructor enables implicit type conversion from a numeric type.
>
>>  CasADi::Matrix< T >::Matrix(const std::vector< T > &x)
>------------------------------------------------------------------------
>
>Construct from a vector.
>
>Thanks to implicit conversion, you can pretend that Matrix(const SX& x);
>exists. Note: above remark applies only to C++, not python or octave
>interfaces
>
>>  CasADi::Matrix< T >::Matrix(const std::vector< T > &x, int n, int m)
>------------------------------------------------------------------------
>
>Construct dense matrix from a vector with the elements in column major
>ordering.
>
>>  CasADi::Matrix< T >::Matrix(const Matrix< A > &x)
>------------------------------------------------------------------------
>
>Create a matrix from a matrix with a different type of matrix entries
>(assuming that the scalar conversion is valid)
>
>>  CasADi::Matrix< T >::Matrix(const std::vector< A > &x)
>------------------------------------------------------------------------
>
>Create an expression from an stl vector.
>
>>  CasADi::Matrix< T >::Matrix(const std::vector< A > &x, int n, int m)
>------------------------------------------------------------------------
>
>Create a non-vector expression from an stl vector.
-}
sxMatrix :: IO SXMatrix
sxMatrix = casADi__Matrix_CasADi__SX___SXMatrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC
  :: Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix'
  :: SXMatrix -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix' :: SXMatrix -> IO SXMatrix
sxMatrix' = casADi__Matrix_CasADi__SX___SXMatrix'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC
  :: CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix''
  :: Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix'' :: Int -> Int -> IO SXMatrix
sxMatrix'' = casADi__Matrix_CasADi__SX___SXMatrix''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC
  :: CInt -> CInt -> Ptr SX' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix'''
  :: Int -> Int -> SX -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix''' :: Int -> Int -> SX -> IO SXMatrix
sxMatrix''' = casADi__Matrix_CasADi__SX___SXMatrix'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC
  :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix''''
  :: Int -> Int -> Vector Int -> Vector Int -> Vector SX -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix'''' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix'''' :: Int -> Int -> Vector Int -> Vector Int -> Vector SX -> IO SXMatrix
sxMatrix'''' = casADi__Matrix_CasADi__SX___SXMatrix''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC
  :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix'''''
  :: Int -> Int -> Vector Int -> Vector Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix''''' :: Int -> Int -> Vector Int -> Vector Int -> IO SXMatrix
sxMatrix''''' = casADi__Matrix_CasADi__SX___SXMatrix'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVecVec (Ptr SX')) -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix''''''
  :: Vector (Vector SX) -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix'''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix'''''' :: Vector (Vector SX) -> IO SXMatrix
sxMatrix'''''' = casADi__Matrix_CasADi__SX___SXMatrix''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr CRSSparsity' -> Ptr SX' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix'''''''
  :: CRSSparsity -> SX -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix''''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix''''''' :: CRSSparsity -> SX -> IO SXMatrix
sxMatrix''''''' = casADi__Matrix_CasADi__SX___SXMatrix'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix''''''''
  :: CRSSparsity -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix'''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix'''''''' :: CRSSparsity -> IO SXMatrix
sxMatrix'''''''' = casADi__Matrix_CasADi__SX___SXMatrix''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr CRSSparsity' -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix'''''''''
  :: CRSSparsity -> Vector SX -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix''''''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix''''''''' :: CRSSparsity -> Vector SX -> IO SXMatrix
sxMatrix''''''''' = casADi__Matrix_CasADi__SX___SXMatrix'''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: CDouble -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix''''''''''
  :: Double -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix'''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix'''''''''' :: Double -> IO SXMatrix
sxMatrix'''''''''' = casADi__Matrix_CasADi__SX___SXMatrix''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec (Ptr SX')) -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix'''''''''''
  :: Vector SX -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix''''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix''''''''''' :: Vector SX -> IO SXMatrix
sxMatrix''''''''''' = casADi__Matrix_CasADi__SX___SXMatrix'''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr SXMatrix')
casADi__Matrix_CasADi__SX___SXMatrix''''''''''''
  :: Vector SX -> Int -> Int -> IO SXMatrix
casADi__Matrix_CasADi__SX___SXMatrix'''''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn

-- classy wrapper
sxMatrix'''''''''''' :: Vector SX -> Int -> Int -> IO SXMatrix
sxMatrix'''''''''''' = casADi__Matrix_CasADi__SX___SXMatrix''''''''''''