casadi-bindings-1.8.0.0: Casadi/Wrappers/Classes/DMatrix.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.DMatrix
       (
         DMatrix,
         DMatrixClass(..),
         dmatrix,
         dmatrix',
         dmatrix'',
         dmatrix''',
         dmatrix'''',
         dmatrix''''',
         dmatrix'''''',
         dmatrix''''''',
         dmatrix'''''''',
         dmatrix''''''''',
         dmatrix'''''''''',
         dmatrix''''''''''',
         dmatrix'''''''''''',
         dmatrix___add__,
         dmatrix___constpow__,
         dmatrix___div__,
         dmatrix___eq__,
         dmatrix___le__,
         dmatrix___lt__,
         dmatrix___mpower__,
         dmatrix___mrdivide__,
         dmatrix___mul__,
         dmatrix___ne__,
         dmatrix___nonzero__,
         dmatrix___pow__,
         dmatrix___sub__,
         dmatrix___truediv__,
         dmatrix_append,
         dmatrix_arccos,
         dmatrix_arccosh,
         dmatrix_arcsin,
         dmatrix_arcsinh,
         dmatrix_arctan,
         dmatrix_arctan2,
         dmatrix_arctanh,
         dmatrix_at,
         dmatrix_binary,
         dmatrix_ceil,
         dmatrix_className,
         dmatrix_clear,
         dmatrix_col,
         dmatrix_cos,
         dmatrix_cosh,
         dmatrix_data,
         dmatrix_elem,
         dmatrix_elem',
         dmatrix_enlarge,
         dmatrix_erase,
         dmatrix_erf,
         dmatrix_erfinv,
         dmatrix_exp,
         dmatrix_eye,
         dmatrix_fabs,
         dmatrix_floor,
         dmatrix_fmax,
         dmatrix_fmin,
         dmatrix_get,
         dmatrix_get',
         dmatrix_get'',
         dmatrix_get''',
         dmatrix_get'''',
         dmatrix_get''''',
         dmatrix_hasNZ,
         dmatrix_if_else_zero,
         dmatrix_inf,
         dmatrix_inf',
         dmatrix_inf'',
         dmatrix_inf''',
         dmatrix_isNull,
         dmatrix_log,
         dmatrix_log10,
         dmatrix_logic_and,
         dmatrix_logic_not,
         dmatrix_logic_or,
         dmatrix_matrix_matrix,
         dmatrix_matrix_scalar,
         dmatrix_mul,
         dmatrix_mul',
         dmatrix_mul_full,
         dmatrix_mul_full',
         dmatrix_mul_no_alloc_nn,
         dmatrix_mul_no_alloc_nn',
         dmatrix_mul_no_alloc_nt,
         dmatrix_mul_no_alloc_tn,
         dmatrix_mul_no_alloc_tn',
         dmatrix_nan,
         dmatrix_nan',
         dmatrix_nan'',
         dmatrix_nan''',
         dmatrix_numel,
         dmatrix_ones,
         dmatrix_ones',
         dmatrix_ones'',
         dmatrix_operator_minus,
         dmatrix_operator_plus,
         dmatrix_printDense',
         dmatrix_printMatrix',
         dmatrix_printScalar',
         dmatrix_printSparse',
         dmatrix_printVector',
         dmatrix_printme,
         dmatrix_quad_form,
         dmatrix_remove,
         dmatrix_repmat,
         dmatrix_repmat',
         dmatrix_reserve,
         dmatrix_reserve',
         dmatrix_resize,
         dmatrix_rowind,
         dmatrix_sanityCheck,
         dmatrix_sanityCheck',
         dmatrix_scalar_matrix,
         dmatrix_set,
         dmatrix_set',
         dmatrix_set'',
         dmatrix_set''',
         dmatrix_set'''',
         dmatrix_set''''',
         dmatrix_setPrecision,
         dmatrix_setScientific,
         dmatrix_setWidth,
         dmatrix_sign,
         dmatrix_sin,
         dmatrix_sinh,
         dmatrix_size,
         dmatrix_size1,
         dmatrix_size2,
         dmatrix_sparse,
         dmatrix_sparse',
         dmatrix_sparse'',
         dmatrix_sparse''',
         dmatrix_sparsityRef,
         dmatrix_sqrt,
         dmatrix_tan,
         dmatrix_tanh,
         dmatrix_trans,
         dmatrix_unary,
         dmatrix_vector,
         dmatrix_zeros,
         dmatrix_zeros',
         dmatrix_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 DMatrix where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___size1" c_CasADi__Matrix_double___size1
  :: Ptr DMatrix' -> IO CInt
casADi__Matrix_double___size1
  :: DMatrix -> IO Int
casADi__Matrix_double___size1 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___size1 x0' >>= wrapReturn

-- classy wrapper
dmatrix_size1 :: DMatrixClass a => a -> IO Int
dmatrix_size1 x = casADi__Matrix_double___size1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___size2" c_CasADi__Matrix_double___size2
  :: Ptr DMatrix' -> IO CInt
casADi__Matrix_double___size2
  :: DMatrix -> IO Int
casADi__Matrix_double___size2 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___size2 x0' >>= wrapReturn

-- classy wrapper
dmatrix_size2 :: DMatrixClass a => a -> IO Int
dmatrix_size2 x = casADi__Matrix_double___size2 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___size" c_CasADi__Matrix_double___size
  :: Ptr DMatrix' -> IO CInt
casADi__Matrix_double___size
  :: DMatrix -> IO Int
casADi__Matrix_double___size x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___size x0' >>= wrapReturn

-- classy wrapper
dmatrix_size :: DMatrixClass a => a -> IO Int
dmatrix_size x = casADi__Matrix_double___size (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___numel" c_CasADi__Matrix_double___numel
  :: Ptr DMatrix' -> IO CInt
casADi__Matrix_double___numel
  :: DMatrix -> IO Int
casADi__Matrix_double___numel x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___numel x0' >>= wrapReturn

-- classy wrapper
dmatrix_numel :: DMatrixClass a => a -> IO Int
dmatrix_numel x = casADi__Matrix_double___numel (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sanityCheck" c_CasADi__Matrix_double___sanityCheck
  :: Ptr DMatrix' -> Ptr CppBool' -> IO ()
casADi__Matrix_double___sanityCheck
  :: DMatrix -> Bool -> IO ()
casADi__Matrix_double___sanityCheck x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___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
-}
dmatrix_sanityCheck :: DMatrixClass a => a -> Bool -> IO ()
dmatrix_sanityCheck x = casADi__Matrix_double___sanityCheck (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sanityCheck_TIC" c_CasADi__Matrix_double___sanityCheck_TIC
  :: Ptr DMatrix' -> IO ()
casADi__Matrix_double___sanityCheck'
  :: DMatrix -> IO ()
casADi__Matrix_double___sanityCheck' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___sanityCheck_TIC x0' >>= wrapReturn

-- classy wrapper
dmatrix_sanityCheck' :: DMatrixClass a => a -> IO ()
dmatrix_sanityCheck' x = casADi__Matrix_double___sanityCheck' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___vector" c_CasADi__Matrix_double___vector
  :: Ptr DMatrix' -> IO (Ptr CppBool')
casADi__Matrix_double___vector
  :: DMatrix -> IO Bool
casADi__Matrix_double___vector x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___vector x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>ublas vector
>
>Check type of matrix
-}
dmatrix_vector :: DMatrixClass a => a -> IO Bool
dmatrix_vector x = casADi__Matrix_double___vector (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___at" c_CasADi__Matrix_double___at
  :: Ptr DMatrix' -> CInt -> IO CDouble
casADi__Matrix_double___at
  :: DMatrix -> Int -> IO Double
casADi__Matrix_double___at x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___at x0' x1' >>= 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.
-}
dmatrix_at :: DMatrixClass a => a -> Int -> IO Double
dmatrix_at x = casADi__Matrix_double___at (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___elem" c_CasADi__Matrix_double___elem
  :: Ptr DMatrix' -> CInt -> CInt -> IO CDouble
casADi__Matrix_double___elem
  :: DMatrix -> Int -> Int -> IO Double
casADi__Matrix_double___elem x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___elem x0' x1' x2' >>= 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
-}
dmatrix_elem :: DMatrixClass a => a -> Int -> Int -> IO Double
dmatrix_elem x = casADi__Matrix_double___elem (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___elem_TIC" c_CasADi__Matrix_double___elem_TIC
  :: Ptr DMatrix' -> CInt -> IO CDouble
casADi__Matrix_double___elem'
  :: DMatrix -> Int -> IO Double
casADi__Matrix_double___elem' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___elem_TIC x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_elem' :: DMatrixClass a => a -> Int -> IO Double
dmatrix_elem' x = casADi__Matrix_double___elem' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___hasNZ" c_CasADi__Matrix_double___hasNZ
  :: Ptr DMatrix' -> CInt -> CInt -> IO (Ptr CppBool')
casADi__Matrix_double___hasNZ
  :: DMatrix -> Int -> Int -> IO Bool
casADi__Matrix_double___hasNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___hasNZ x0' x1' x2' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>Returns true if the matrix has a non-zero at location i,j.
-}
dmatrix_hasNZ :: DMatrixClass a => a -> Int -> Int -> IO Bool
dmatrix_hasNZ x = casADi__Matrix_double___hasNZ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____nonzero__" c_CasADi__Matrix_double_____nonzero__
  :: Ptr DMatrix' -> IO (Ptr CppBool')
casADi__Matrix_double_____nonzero__
  :: DMatrix -> IO Bool
casADi__Matrix_double_____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double_____nonzero__ x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>Returns the truth value of a Matrix.
-}
dmatrix___nonzero__ :: DMatrixClass a => a -> IO Bool
dmatrix___nonzero__ x = casADi__Matrix_double_____nonzero__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___append" c_CasADi__Matrix_double___append
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casADi__Matrix_double___append
  :: DMatrix -> DMatrix -> IO ()
casADi__Matrix_double___append x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___append x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Append a matrix to the end.
-}
dmatrix_append :: DMatrixClass a => a -> DMatrix -> IO ()
dmatrix_append x = casADi__Matrix_double___append (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___operator_plus" c_CasADi__Matrix_double___operator_plus
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___operator_plus
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___operator_plus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___operator_plus x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_operator_plus :: DMatrixClass a => a -> IO DMatrix
dmatrix_operator_plus x = casADi__Matrix_double___operator_plus (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___operator_minus" c_CasADi__Matrix_double___operator_minus
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___operator_minus
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___operator_minus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___operator_minus x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_operator_minus :: DMatrixClass a => a -> IO DMatrix
dmatrix_operator_minus x = casADi__Matrix_double___operator_minus (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___binary" c_CasADi__Matrix_double___binary
  :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___binary
  :: Int -> DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___binary x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___binary x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
dmatrix_binary :: Int -> DMatrix -> DMatrix -> IO DMatrix
dmatrix_binary = casADi__Matrix_double___binary


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___unary" c_CasADi__Matrix_double___unary
  :: CInt -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___unary
  :: Int -> DMatrix -> IO DMatrix
casADi__Matrix_double___unary x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___unary x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
dmatrix_unary :: Int -> DMatrix -> IO DMatrix
dmatrix_unary = casADi__Matrix_double___unary


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___scalar_matrix" c_CasADi__Matrix_double___scalar_matrix
  :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___scalar_matrix
  :: Int -> DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___scalar_matrix x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___scalar_matrix x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
dmatrix_scalar_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix
dmatrix_scalar_matrix = casADi__Matrix_double___scalar_matrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___matrix_scalar" c_CasADi__Matrix_double___matrix_scalar
  :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___matrix_scalar
  :: Int -> DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___matrix_scalar x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___matrix_scalar x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
dmatrix_matrix_scalar :: Int -> DMatrix -> DMatrix -> IO DMatrix
dmatrix_matrix_scalar = casADi__Matrix_double___matrix_scalar


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___matrix_matrix" c_CasADi__Matrix_double___matrix_matrix
  :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___matrix_matrix
  :: Int -> DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___matrix_matrix x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___matrix_matrix x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
dmatrix_matrix_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix
dmatrix_matrix_matrix = casADi__Matrix_double___matrix_matrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____add__" c_CasADi__Matrix_double_____add__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____add__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____add__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____add__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___add__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___add__ x = casADi__Matrix_double_____add__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____sub__" c_CasADi__Matrix_double_____sub__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____sub__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____sub__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____sub__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___sub__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___sub__ x = casADi__Matrix_double_____sub__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____mul__" c_CasADi__Matrix_double_____mul__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____mul__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____mul__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____mul__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___mul__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___mul__ x = casADi__Matrix_double_____mul__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____div__" c_CasADi__Matrix_double_____div__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____div__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____div__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____div__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___div__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___div__ x = casADi__Matrix_double_____div__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____lt__" c_CasADi__Matrix_double_____lt__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____lt__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____lt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____lt__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___lt__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___lt__ x = casADi__Matrix_double_____lt__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____le__" c_CasADi__Matrix_double_____le__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____le__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____le__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____le__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___le__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___le__ x = casADi__Matrix_double_____le__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____eq__" c_CasADi__Matrix_double_____eq__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____eq__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____eq__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____eq__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___eq__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___eq__ x = casADi__Matrix_double_____eq__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____ne__" c_CasADi__Matrix_double_____ne__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____ne__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____ne__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____ne__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___ne__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___ne__ x = casADi__Matrix_double_____ne__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____truediv__" c_CasADi__Matrix_double_____truediv__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____truediv__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____truediv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____truediv__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___truediv__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___truediv__ x = casADi__Matrix_double_____truediv__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____pow__" c_CasADi__Matrix_double_____pow__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____pow__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____pow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____pow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___pow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___pow__ x = casADi__Matrix_double_____pow__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____constpow__" c_CasADi__Matrix_double_____constpow__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____constpow__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____constpow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____constpow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___constpow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___constpow__ x = casADi__Matrix_double_____constpow__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____mpower__" c_CasADi__Matrix_double_____mpower__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____mpower__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____mpower__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____mpower__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___mpower__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___mpower__ x = casADi__Matrix_double_____mpower__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double_____mrdivide__" c_CasADi__Matrix_double_____mrdivide__
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double_____mrdivide__
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double_____mrdivide__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double_____mrdivide__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Elementwise operations Octave/Python naming.
-}
dmatrix___mrdivide__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___mrdivide__ x = casADi__Matrix_double_____mrdivide__ (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul_full" c_CasADi__Matrix_double___mul_full
  :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr CRSSparsity' -> IO (Ptr DMatrix')
casADi__Matrix_double___mul_full
  :: DMatrix -> DMatrix -> CRSSparsity -> IO DMatrix
casADi__Matrix_double___mul_full x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___mul_full x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Matrix-matrix product.
-}
dmatrix_mul_full :: DMatrixClass a => a -> DMatrix -> CRSSparsity -> IO DMatrix
dmatrix_mul_full x = casADi__Matrix_double___mul_full (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul_full_TIC" c_CasADi__Matrix_double___mul_full_TIC
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___mul_full'
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___mul_full' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___mul_full_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_mul_full' :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_mul_full' x = casADi__Matrix_double___mul_full' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul" c_CasADi__Matrix_double___mul
  :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr CRSSparsity' -> IO (Ptr DMatrix')
casADi__Matrix_double___mul
  :: DMatrix -> DMatrix -> CRSSparsity -> IO DMatrix
casADi__Matrix_double___mul x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___mul x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Matrix-matrix product.
-}
dmatrix_mul :: DMatrixClass a => a -> DMatrix -> CRSSparsity -> IO DMatrix
dmatrix_mul x = casADi__Matrix_double___mul (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul_TIC" c_CasADi__Matrix_double___mul_TIC
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___mul'
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___mul' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___mul_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_mul' :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_mul' x = casADi__Matrix_double___mul' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nn" c_CasADi__Matrix_double___mul_no_alloc_nn
  :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casADi__Matrix_double___mul_no_alloc_nn
  :: DMatrix -> DMatrix -> DMatrix -> IO ()
casADi__Matrix_double___mul_no_alloc_nn x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_mul_no_alloc_nn :: DMatrix -> DMatrix -> DMatrix -> IO ()
dmatrix_mul_no_alloc_nn = casADi__Matrix_double___mul_no_alloc_nn


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nt" c_CasADi__Matrix_double___mul_no_alloc_nt
  :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casADi__Matrix_double___mul_no_alloc_nt
  :: DMatrix -> DMatrix -> DMatrix -> IO ()
casADi__Matrix_double___mul_no_alloc_nt x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_mul_no_alloc_nt :: DMatrix -> DMatrix -> DMatrix -> IO ()
dmatrix_mul_no_alloc_nt = casADi__Matrix_double___mul_no_alloc_nt


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_tn" c_CasADi__Matrix_double___mul_no_alloc_tn
  :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casADi__Matrix_double___mul_no_alloc_tn
  :: DMatrix -> DMatrix -> DMatrix -> IO ()
casADi__Matrix_double___mul_no_alloc_tn x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_mul_no_alloc_tn :: DMatrix -> DMatrix -> DMatrix -> IO ()
dmatrix_mul_no_alloc_tn = casADi__Matrix_double___mul_no_alloc_tn


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nn_TIC" c_CasADi__Matrix_double___mul_no_alloc_nn_TIC
  :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> Ptr (CppVec CDouble) -> IO ()
casADi__Matrix_double___mul_no_alloc_nn'
  :: DMatrix -> Vector Double -> Vector Double -> IO ()
casADi__Matrix_double___mul_no_alloc_nn' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_mul_no_alloc_nn' :: DMatrix -> Vector Double -> Vector Double -> IO ()
dmatrix_mul_no_alloc_nn' = casADi__Matrix_double___mul_no_alloc_nn'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_tn_TIC" c_CasADi__Matrix_double___mul_no_alloc_tn_TIC
  :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> Ptr (CppVec CDouble) -> IO ()
casADi__Matrix_double___mul_no_alloc_tn'
  :: DMatrix -> Vector Double -> Vector Double -> IO ()
casADi__Matrix_double___mul_no_alloc_tn' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_mul_no_alloc_tn' :: DMatrix -> Vector Double -> Vector Double -> IO ()
dmatrix_mul_no_alloc_tn' = casADi__Matrix_double___mul_no_alloc_tn'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___quad_form" c_CasADi__Matrix_double___quad_form
  :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO CDouble
casADi__Matrix_double___quad_form
  :: DMatrix -> Vector Double -> IO Double
casADi__Matrix_double___quad_form x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___quad_form x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_quad_form :: DMatrix -> Vector Double -> IO Double
dmatrix_quad_form = casADi__Matrix_double___quad_form


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___trans" c_CasADi__Matrix_double___trans
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___trans
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___trans x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___trans x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Matrix transpose.
-}
dmatrix_trans :: DMatrixClass a => a -> IO DMatrix
dmatrix_trans x = casADi__Matrix_double___trans (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sin" c_CasADi__Matrix_double___sin
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___sin
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___sin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___sin x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_sin :: DMatrixClass a => a -> IO DMatrix
dmatrix_sin x = casADi__Matrix_double___sin (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___cos" c_CasADi__Matrix_double___cos
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___cos
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___cos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___cos x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_cos :: DMatrixClass a => a -> IO DMatrix
dmatrix_cos x = casADi__Matrix_double___cos (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___tan" c_CasADi__Matrix_double___tan
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___tan
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___tan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___tan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_tan :: DMatrixClass a => a -> IO DMatrix
dmatrix_tan x = casADi__Matrix_double___tan (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___arcsin" c_CasADi__Matrix_double___arcsin
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___arcsin
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___arcsin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___arcsin x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_arcsin :: DMatrixClass a => a -> IO DMatrix
dmatrix_arcsin x = casADi__Matrix_double___arcsin (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___arccos" c_CasADi__Matrix_double___arccos
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___arccos
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___arccos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___arccos x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_arccos :: DMatrixClass a => a -> IO DMatrix
dmatrix_arccos x = casADi__Matrix_double___arccos (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___arctan" c_CasADi__Matrix_double___arctan
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___arctan
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___arctan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___arctan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_arctan :: DMatrixClass a => a -> IO DMatrix
dmatrix_arctan x = casADi__Matrix_double___arctan (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___exp" c_CasADi__Matrix_double___exp
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___exp
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___exp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___exp x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_exp :: DMatrixClass a => a -> IO DMatrix
dmatrix_exp x = casADi__Matrix_double___exp (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___log" c_CasADi__Matrix_double___log
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___log
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___log x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___log x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_log :: DMatrixClass a => a -> IO DMatrix
dmatrix_log x = casADi__Matrix_double___log (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sqrt" c_CasADi__Matrix_double___sqrt
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___sqrt
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___sqrt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___sqrt x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_sqrt :: DMatrixClass a => a -> IO DMatrix
dmatrix_sqrt x = casADi__Matrix_double___sqrt (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___floor" c_CasADi__Matrix_double___floor
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___floor
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___floor x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___floor x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_floor :: DMatrixClass a => a -> IO DMatrix
dmatrix_floor x = casADi__Matrix_double___floor (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___ceil" c_CasADi__Matrix_double___ceil
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___ceil
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___ceil x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___ceil x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_ceil :: DMatrixClass a => a -> IO DMatrix
dmatrix_ceil x = casADi__Matrix_double___ceil (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___fabs" c_CasADi__Matrix_double___fabs
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___fabs
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___fabs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___fabs x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_fabs :: DMatrixClass a => a -> IO DMatrix
dmatrix_fabs x = casADi__Matrix_double___fabs (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sign" c_CasADi__Matrix_double___sign
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___sign
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___sign x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___sign x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_sign :: DMatrixClass a => a -> IO DMatrix
dmatrix_sign x = casADi__Matrix_double___sign (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___erfinv" c_CasADi__Matrix_double___erfinv
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___erfinv
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___erfinv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___erfinv x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_erfinv :: DMatrixClass a => a -> IO DMatrix
dmatrix_erfinv x = casADi__Matrix_double___erfinv (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___fmin" c_CasADi__Matrix_double___fmin
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___fmin
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___fmin x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___fmin x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_fmin :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_fmin x = casADi__Matrix_double___fmin (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___fmax" c_CasADi__Matrix_double___fmax
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___fmax
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___fmax x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___fmax x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_fmax :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_fmax x = casADi__Matrix_double___fmax (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___erf" c_CasADi__Matrix_double___erf
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___erf
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___erf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___erf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_erf :: DMatrixClass a => a -> IO DMatrix
dmatrix_erf x = casADi__Matrix_double___erf (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sinh" c_CasADi__Matrix_double___sinh
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___sinh
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___sinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___sinh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_sinh :: DMatrixClass a => a -> IO DMatrix
dmatrix_sinh x = casADi__Matrix_double___sinh (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___cosh" c_CasADi__Matrix_double___cosh
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___cosh
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___cosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___cosh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_cosh :: DMatrixClass a => a -> IO DMatrix
dmatrix_cosh x = casADi__Matrix_double___cosh (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___tanh" c_CasADi__Matrix_double___tanh
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___tanh
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___tanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___tanh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_tanh :: DMatrixClass a => a -> IO DMatrix
dmatrix_tanh x = casADi__Matrix_double___tanh (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___arcsinh" c_CasADi__Matrix_double___arcsinh
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___arcsinh
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___arcsinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___arcsinh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_arcsinh :: DMatrixClass a => a -> IO DMatrix
dmatrix_arcsinh x = casADi__Matrix_double___arcsinh (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___arccosh" c_CasADi__Matrix_double___arccosh
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___arccosh
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___arccosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___arccosh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_arccosh :: DMatrixClass a => a -> IO DMatrix
dmatrix_arccosh x = casADi__Matrix_double___arccosh (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___arctanh" c_CasADi__Matrix_double___arctanh
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___arctanh
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___arctanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___arctanh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_arctanh :: DMatrixClass a => a -> IO DMatrix
dmatrix_arctanh x = casADi__Matrix_double___arctanh (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___arctan2" c_CasADi__Matrix_double___arctan2
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___arctan2
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___arctan2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___arctan2 x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_arctan2 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_arctan2 x = casADi__Matrix_double___arctan2 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___log10" c_CasADi__Matrix_double___log10
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___log10
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___log10 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___log10 x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_log10 :: DMatrixClass a => a -> IO DMatrix
dmatrix_log10 x = casADi__Matrix_double___log10 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___printme" c_CasADi__Matrix_double___printme
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___printme
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___printme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___printme x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_printme :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_printme x = casADi__Matrix_double___printme (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___logic_not" c_CasADi__Matrix_double___logic_not
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___logic_not
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___logic_not x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___logic_not x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_logic_not :: DMatrixClass a => a -> IO DMatrix
dmatrix_logic_not x = casADi__Matrix_double___logic_not (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___logic_and" c_CasADi__Matrix_double___logic_and
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___logic_and
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___logic_and x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___logic_and x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_logic_and :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_logic_and x = casADi__Matrix_double___logic_and (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___logic_or" c_CasADi__Matrix_double___logic_or
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___logic_or
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___logic_or x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___logic_or x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_logic_or :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_logic_or x = casADi__Matrix_double___logic_or (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___if_else_zero" c_CasADi__Matrix_double___if_else_zero
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___if_else_zero
  :: DMatrix -> DMatrix -> IO DMatrix
casADi__Matrix_double___if_else_zero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___if_else_zero x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>Operations defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
dmatrix_if_else_zero :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_if_else_zero x = casADi__Matrix_double___if_else_zero (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___className" c_CasADi__Matrix_double___className
  :: IO (Ptr StdString')
casADi__Matrix_double___className
  :: IO String
casADi__Matrix_double___className  =
  c_CasADi__Matrix_double___className  >>= (newForeignPtr c_delete_std__string) >>= wrapReturn

-- classy wrapper
{-|
>Printing.
-}
dmatrix_className :: IO String
dmatrix_className = casADi__Matrix_double___className


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___printScalar_TIC" c_CasADi__Matrix_double___printScalar_TIC
  :: Ptr DMatrix' -> IO ()
casADi__Matrix_double___printScalar'
  :: DMatrix -> IO ()
casADi__Matrix_double___printScalar' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___printScalar_TIC x0' >>= wrapReturn

-- classy wrapper
dmatrix_printScalar' :: DMatrixClass a => a -> IO ()
dmatrix_printScalar' x = casADi__Matrix_double___printScalar' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___printVector_TIC" c_CasADi__Matrix_double___printVector_TIC
  :: Ptr DMatrix' -> IO ()
casADi__Matrix_double___printVector'
  :: DMatrix -> IO ()
casADi__Matrix_double___printVector' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___printVector_TIC x0' >>= wrapReturn

-- classy wrapper
dmatrix_printVector' :: DMatrixClass a => a -> IO ()
dmatrix_printVector' x = casADi__Matrix_double___printVector' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___printMatrix_TIC" c_CasADi__Matrix_double___printMatrix_TIC
  :: Ptr DMatrix' -> IO ()
casADi__Matrix_double___printMatrix'
  :: DMatrix -> IO ()
casADi__Matrix_double___printMatrix' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___printMatrix_TIC x0' >>= wrapReturn

-- classy wrapper
dmatrix_printMatrix' :: DMatrixClass a => a -> IO ()
dmatrix_printMatrix' x = casADi__Matrix_double___printMatrix' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___printSparse_TIC" c_CasADi__Matrix_double___printSparse_TIC
  :: Ptr DMatrix' -> IO ()
casADi__Matrix_double___printSparse'
  :: DMatrix -> IO ()
casADi__Matrix_double___printSparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___printSparse_TIC x0' >>= wrapReturn

-- classy wrapper
dmatrix_printSparse' :: DMatrixClass a => a -> IO ()
dmatrix_printSparse' x = casADi__Matrix_double___printSparse' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___printDense_TIC" c_CasADi__Matrix_double___printDense_TIC
  :: Ptr DMatrix' -> IO ()
casADi__Matrix_double___printDense'
  :: DMatrix -> IO ()
casADi__Matrix_double___printDense' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___printDense_TIC x0' >>= wrapReturn

-- classy wrapper
dmatrix_printDense' :: DMatrixClass a => a -> IO ()
dmatrix_printDense' x = casADi__Matrix_double___printDense' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___col" c_CasADi__Matrix_double___col
  :: Ptr DMatrix' -> CInt -> IO CInt
casADi__Matrix_double___col
  :: DMatrix -> Int -> IO Int
casADi__Matrix_double___col x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___col x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_col :: DMatrixClass a => a -> Int -> IO Int
dmatrix_col x = casADi__Matrix_double___col (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___rowind" c_CasADi__Matrix_double___rowind
  :: Ptr DMatrix' -> CInt -> IO CInt
casADi__Matrix_double___rowind
  :: DMatrix -> Int -> IO Int
casADi__Matrix_double___rowind x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___rowind x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_rowind :: DMatrixClass a => a -> Int -> IO Int
dmatrix_rowind x = casADi__Matrix_double___rowind (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___clear" c_CasADi__Matrix_double___clear
  :: Ptr DMatrix' -> IO ()
casADi__Matrix_double___clear
  :: DMatrix -> IO ()
casADi__Matrix_double___clear x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___clear x0' >>= wrapReturn

-- classy wrapper
dmatrix_clear :: DMatrixClass a => a -> IO ()
dmatrix_clear x = casADi__Matrix_double___clear (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___resize" c_CasADi__Matrix_double___resize
  :: Ptr DMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_double___resize
  :: DMatrix -> Int -> Int -> IO ()
casADi__Matrix_double___resize x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___resize x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_resize :: DMatrixClass a => a -> Int -> Int -> IO ()
dmatrix_resize x = casADi__Matrix_double___resize (castDMatrix x)


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

-- classy wrapper
dmatrix_reserve :: DMatrixClass a => a -> Int -> IO ()
dmatrix_reserve x = casADi__Matrix_double___reserve (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___reserve_TIC" c_CasADi__Matrix_double___reserve_TIC
  :: Ptr DMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_double___reserve'
  :: DMatrix -> Int -> Int -> IO ()
casADi__Matrix_double___reserve' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___reserve_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_reserve' :: DMatrixClass a => a -> Int -> Int -> IO ()
dmatrix_reserve' x = casADi__Matrix_double___reserve' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___erase" c_CasADi__Matrix_double___erase
  :: Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_double___erase
  :: DMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_double___erase x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___erase x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Erase a submatrix Erase rows and/or columns of a matrix.
-}
dmatrix_erase :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
dmatrix_erase x = casADi__Matrix_double___erase (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___remove" c_CasADi__Matrix_double___remove
  :: Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_double___remove
  :: DMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_double___remove x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___remove x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Remove rows or columns Rremove/delete rows and/or columns of a matrix.
-}
dmatrix_remove :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
dmatrix_remove x = casADi__Matrix_double___remove (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___enlarge" c_CasADi__Matrix_double___enlarge
  :: Ptr DMatrix' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_double___enlarge
  :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_double___enlarge x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_double___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.
-}
dmatrix_enlarge :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
dmatrix_enlarge x = casADi__Matrix_double___enlarge (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___data" c_CasADi__Matrix_double___data
  :: Ptr DMatrix' -> IO (Ptr (CppVec CDouble))
casADi__Matrix_double___data
  :: DMatrix -> IO (Vector Double)
casADi__Matrix_double___data x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___data x0' >>= (newForeignPtr c_delete_std__vector_double_) >>= 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.
-}
dmatrix_data :: DMatrixClass a => a -> IO (Vector Double)
dmatrix_data x = casADi__Matrix_double___data (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sparsityRef" c_CasADi__Matrix_double___sparsityRef
  :: Ptr DMatrix' -> IO (Ptr CRSSparsity')
casADi__Matrix_double___sparsityRef
  :: DMatrix -> IO CRSSparsity
casADi__Matrix_double___sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___sparsityRef x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
{-|
>Access the sparsity, make a copy if there are multiple references to it.
-}
dmatrix_sparsityRef :: DMatrixClass a => a -> IO CRSSparsity
dmatrix_sparsityRef x = casADi__Matrix_double___sparsityRef (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___set" c_CasADi__Matrix_double___set
  :: Ptr DMatrix' -> CDouble -> CInt -> IO ()
casADi__Matrix_double___set
  :: DMatrix -> Double -> Sparsity -> IO ()
casADi__Matrix_double___set x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___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.
-}
dmatrix_set :: DMatrixClass a => a -> Double -> Sparsity -> IO ()
dmatrix_set x = casADi__Matrix_double___set (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___set_TIC" c_CasADi__Matrix_double___set_TIC
  :: Ptr DMatrix' -> CDouble -> IO ()
casADi__Matrix_double___set'
  :: DMatrix -> Double -> IO ()
casADi__Matrix_double___set' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___set_TIC x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_set' :: DMatrixClass a => a -> Double -> IO ()
dmatrix_set' x = casADi__Matrix_double___set' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___get" c_CasADi__Matrix_double___get
  :: Ptr DMatrix' -> CDouble -> CInt -> IO ()
casADi__Matrix_double___get
  :: DMatrix -> Double -> Sparsity -> IO ()
casADi__Matrix_double___get x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___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.
-}
dmatrix_get :: DMatrixClass a => a -> Double -> Sparsity -> IO ()
dmatrix_get x = casADi__Matrix_double___get (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___get_TIC" c_CasADi__Matrix_double___get_TIC
  :: Ptr DMatrix' -> CDouble -> IO ()
casADi__Matrix_double___get'
  :: DMatrix -> Double -> IO ()
casADi__Matrix_double___get' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___get_TIC x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_get' :: DMatrixClass a => a -> Double -> IO ()
dmatrix_get' x = casADi__Matrix_double___get' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC
  :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> CInt -> IO ()
casADi__Matrix_double___set''
  :: DMatrix -> Vector Double -> Sparsity -> IO ()
casADi__Matrix_double___set'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___set_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_set'' :: DMatrixClass a => a -> Vector Double -> Sparsity -> IO ()
dmatrix_set'' x = casADi__Matrix_double___set'' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC
  :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO ()
casADi__Matrix_double___set'''
  :: DMatrix -> Vector Double -> IO ()
casADi__Matrix_double___set''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___set_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_set''' :: DMatrixClass a => a -> Vector Double -> IO ()
dmatrix_set''' x = casADi__Matrix_double___set''' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC
  :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> CInt -> IO ()
casADi__Matrix_double___get''
  :: DMatrix -> Vector Double -> Sparsity -> IO ()
casADi__Matrix_double___get'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___get_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_get'' :: DMatrixClass a => a -> Vector Double -> Sparsity -> IO ()
dmatrix_get'' x = casADi__Matrix_double___get'' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC
  :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO ()
casADi__Matrix_double___get'''
  :: DMatrix -> Vector Double -> IO ()
casADi__Matrix_double___get''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___get_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_get''' :: DMatrixClass a => a -> Vector Double -> IO ()
dmatrix_get''' x = casADi__Matrix_double___get''' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC
  :: Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO ()
casADi__Matrix_double___set''''
  :: DMatrix -> DMatrix -> Sparsity -> IO ()
casADi__Matrix_double___set'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_set'''' :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO ()
dmatrix_set'''' x = casADi__Matrix_double___set'''' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casADi__Matrix_double___set'''''
  :: DMatrix -> DMatrix -> IO ()
casADi__Matrix_double___set''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_set''''' :: DMatrixClass a => a -> DMatrix -> IO ()
dmatrix_set''''' x = casADi__Matrix_double___set''''' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC
  :: Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO ()
casADi__Matrix_double___get''''
  :: DMatrix -> DMatrix -> Sparsity -> IO ()
casADi__Matrix_double___get'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
dmatrix_get'''' :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO ()
dmatrix_get'''' x = casADi__Matrix_double___get'''' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC
  :: Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casADi__Matrix_double___get'''''
  :: DMatrix -> DMatrix -> IO ()
casADi__Matrix_double___get''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
dmatrix_get''''' :: DMatrixClass a => a -> DMatrix -> IO ()
dmatrix_get''''' x = casADi__Matrix_double___get''''' (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sparse" c_CasADi__Matrix_double___sparse
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___sparse
  :: Int -> Int -> IO DMatrix
casADi__Matrix_double___sparse x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___sparse x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= 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.
-}
dmatrix_sparse :: Int -> Int -> IO DMatrix
dmatrix_sparse = casADi__Matrix_double___sparse


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sparse_TIC" c_CasADi__Matrix_double___sparse_TIC
  :: CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___sparse'
  :: Int -> IO DMatrix
casADi__Matrix_double___sparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___sparse_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_sparse' :: Int -> IO DMatrix
dmatrix_sparse' = casADi__Matrix_double___sparse'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sparse_TIC_TIC" c_CasADi__Matrix_double___sparse_TIC_TIC
  :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CDouble) -> IO (Ptr DMatrix')
casADi__Matrix_double___sparse''
  :: Vector Int -> Vector Int -> Vector Double -> IO DMatrix
casADi__Matrix_double___sparse'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___sparse_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_sparse'' :: Vector Int -> Vector Int -> Vector Double -> IO DMatrix
dmatrix_sparse'' = casADi__Matrix_double___sparse''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___sparse_TIC_TIC_TIC" c_CasADi__Matrix_double___sparse_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CDouble) -> CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___sparse'''
  :: Vector Int -> Vector Int -> Vector Double -> Int -> Int -> IO DMatrix
casADi__Matrix_double___sparse''' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_double___sparse_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_sparse''' :: Vector Int -> Vector Int -> Vector Double -> Int -> Int -> IO DMatrix
dmatrix_sparse''' = casADi__Matrix_double___sparse'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___zeros" c_CasADi__Matrix_double___zeros
  :: Ptr CRSSparsity' -> IO (Ptr DMatrix')
casADi__Matrix_double___zeros
  :: CRSSparsity -> IO DMatrix
casADi__Matrix_double___zeros x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___zeros x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>create a dense matrix with all zeros
-}
dmatrix_zeros :: CRSSparsity -> IO DMatrix
dmatrix_zeros = casADi__Matrix_double___zeros


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___zeros_TIC" c_CasADi__Matrix_double___zeros_TIC
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___zeros'
  :: Int -> Int -> IO DMatrix
casADi__Matrix_double___zeros' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___zeros_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_zeros' :: Int -> Int -> IO DMatrix
dmatrix_zeros' = casADi__Matrix_double___zeros'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___zeros_TIC_TIC" c_CasADi__Matrix_double___zeros_TIC_TIC
  :: CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___zeros''
  :: Int -> IO DMatrix
casADi__Matrix_double___zeros'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___zeros_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_zeros'' :: Int -> IO DMatrix
dmatrix_zeros'' = casADi__Matrix_double___zeros''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___ones" c_CasADi__Matrix_double___ones
  :: Ptr CRSSparsity' -> IO (Ptr DMatrix')
casADi__Matrix_double___ones
  :: CRSSparsity -> IO DMatrix
casADi__Matrix_double___ones x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___ones x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all ones
-}
dmatrix_ones :: CRSSparsity -> IO DMatrix
dmatrix_ones = casADi__Matrix_double___ones


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___ones_TIC" c_CasADi__Matrix_double___ones_TIC
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___ones'
  :: Int -> Int -> IO DMatrix
casADi__Matrix_double___ones' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___ones_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_ones' :: Int -> Int -> IO DMatrix
dmatrix_ones' = casADi__Matrix_double___ones'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___ones_TIC_TIC" c_CasADi__Matrix_double___ones_TIC_TIC
  :: CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___ones''
  :: Int -> IO DMatrix
casADi__Matrix_double___ones'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___ones_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_ones'' :: Int -> IO DMatrix
dmatrix_ones'' = casADi__Matrix_double___ones''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___inf" c_CasADi__Matrix_double___inf
  :: Ptr CRSSparsity' -> IO (Ptr DMatrix')
casADi__Matrix_double___inf
  :: CRSSparsity -> IO DMatrix
casADi__Matrix_double___inf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___inf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all inf
-}
dmatrix_inf :: CRSSparsity -> IO DMatrix
dmatrix_inf = casADi__Matrix_double___inf


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC" c_CasADi__Matrix_double___inf_TIC
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___inf'
  :: Int -> Int -> IO DMatrix
casADi__Matrix_double___inf' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___inf_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_inf' :: Int -> Int -> IO DMatrix
dmatrix_inf' = casADi__Matrix_double___inf'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC_TIC" c_CasADi__Matrix_double___inf_TIC_TIC
  :: CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___inf''
  :: Int -> IO DMatrix
casADi__Matrix_double___inf'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___inf_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_inf'' :: Int -> IO DMatrix
dmatrix_inf'' = casADi__Matrix_double___inf''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC_TIC_TIC" c_CasADi__Matrix_double___inf_TIC_TIC_TIC
  :: IO (Ptr DMatrix')
casADi__Matrix_double___inf'''
  :: IO DMatrix
casADi__Matrix_double___inf'''  =
  c_CasADi__Matrix_double___inf_TIC_TIC_TIC  >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_inf''' :: IO DMatrix
dmatrix_inf''' = casADi__Matrix_double___inf'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___nan" c_CasADi__Matrix_double___nan
  :: Ptr CRSSparsity' -> IO (Ptr DMatrix')
casADi__Matrix_double___nan
  :: CRSSparsity -> IO DMatrix
casADi__Matrix_double___nan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___nan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all nan
-}
dmatrix_nan :: CRSSparsity -> IO DMatrix
dmatrix_nan = casADi__Matrix_double___nan


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC" c_CasADi__Matrix_double___nan_TIC
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___nan'
  :: Int -> Int -> IO DMatrix
casADi__Matrix_double___nan' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___nan_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_nan' :: Int -> Int -> IO DMatrix
dmatrix_nan' = casADi__Matrix_double___nan'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC_TIC" c_CasADi__Matrix_double___nan_TIC_TIC
  :: CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___nan''
  :: Int -> IO DMatrix
casADi__Matrix_double___nan'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___nan_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_nan'' :: Int -> IO DMatrix
dmatrix_nan'' = casADi__Matrix_double___nan''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC_TIC_TIC" c_CasADi__Matrix_double___nan_TIC_TIC_TIC
  :: IO (Ptr DMatrix')
casADi__Matrix_double___nan'''
  :: IO DMatrix
casADi__Matrix_double___nan'''  =
  c_CasADi__Matrix_double___nan_TIC_TIC_TIC  >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_nan''' :: IO DMatrix
dmatrix_nan''' = casADi__Matrix_double___nan'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___repmat" c_CasADi__Matrix_double___repmat
  :: Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___repmat
  :: DMatrix -> Int -> Int -> IO DMatrix
casADi__Matrix_double___repmat x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___repmat x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix by repeating an existing matrix
-}
dmatrix_repmat :: DMatrix -> Int -> Int -> IO DMatrix
dmatrix_repmat = casADi__Matrix_double___repmat


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___repmat_TIC" c_CasADi__Matrix_double___repmat_TIC
  :: Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___repmat'
  :: DMatrix -> Int -> IO DMatrix
casADi__Matrix_double___repmat' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___repmat_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_repmat' :: DMatrix -> Int -> IO DMatrix
dmatrix_repmat' = casADi__Matrix_double___repmat'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___eye" c_CasADi__Matrix_double___eye
  :: CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___eye
  :: Int -> IO DMatrix
casADi__Matrix_double___eye x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___eye x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix_eye :: Int -> IO DMatrix
dmatrix_eye = casADi__Matrix_double___eye


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___isNull" c_CasADi__Matrix_double___isNull
  :: Ptr DMatrix' -> IO (Ptr CppBool')
casADi__Matrix_double___isNull
  :: DMatrix -> IO Bool
casADi__Matrix_double___isNull x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___isNull x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>The following function is used to ensure similarity to MX, which is
>reference counted.
-}
dmatrix_isNull :: DMatrixClass a => a -> IO Bool
dmatrix_isNull x = casADi__Matrix_double___isNull (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___setPrecision" c_CasADi__Matrix_double___setPrecision
  :: CInt -> IO ()
casADi__Matrix_double___setPrecision
  :: Int -> IO ()
casADi__Matrix_double___setPrecision x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___setPrecision x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___setWidth" c_CasADi__Matrix_double___setWidth
  :: CInt -> IO ()
casADi__Matrix_double___setWidth
  :: Int -> IO ()
casADi__Matrix_double___setWidth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___setWidth x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___setScientific" c_CasADi__Matrix_double___setScientific
  :: Ptr CppBool' -> IO ()
casADi__Matrix_double___setScientific
  :: Bool -> IO ()
casADi__Matrix_double___setScientific x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___setScientific x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix" c_CasADi__Matrix_double___DMatrix
  :: IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix
  :: IO DMatrix
casADi__Matrix_double___DMatrix  =
  c_CasADi__Matrix_double___DMatrix  >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= 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.
-}
dmatrix :: IO DMatrix
dmatrix = casADi__Matrix_double___DMatrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC" c_CasADi__Matrix_double___DMatrix_TIC
  :: Ptr DMatrix' -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix'
  :: DMatrix -> IO DMatrix
casADi__Matrix_double___DMatrix' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___DMatrix_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix' :: DMatrix -> IO DMatrix
dmatrix' = casADi__Matrix_double___DMatrix'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC
  :: CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix''
  :: Int -> Int -> IO DMatrix
casADi__Matrix_double___DMatrix'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix'' :: Int -> Int -> IO DMatrix
dmatrix'' = casADi__Matrix_double___DMatrix''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC
  :: CInt -> CInt -> CDouble -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix'''
  :: Int -> Int -> Double -> IO DMatrix
casADi__Matrix_double___DMatrix''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix''' :: Int -> Int -> Double -> IO DMatrix
dmatrix''' = casADi__Matrix_double___DMatrix'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC
  :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CDouble) -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix''''
  :: Int -> Int -> Vector Int -> Vector Int -> Vector Double -> IO DMatrix
casADi__Matrix_double___DMatrix'''' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix'''' :: Int -> Int -> Vector Int -> Vector Int -> Vector Double -> IO DMatrix
dmatrix'''' = casADi__Matrix_double___DMatrix''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC
  :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix'''''
  :: Int -> Int -> Vector Int -> Vector Int -> IO DMatrix
casADi__Matrix_double___DMatrix''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix''''' :: Int -> Int -> Vector Int -> Vector Int -> IO DMatrix
dmatrix''''' = casADi__Matrix_double___DMatrix'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVecVec CDouble) -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix''''''
  :: Vector (Vector Double) -> IO DMatrix
casADi__Matrix_double___DMatrix'''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix'''''' :: Vector (Vector Double) -> IO DMatrix
dmatrix'''''' = casADi__Matrix_double___DMatrix''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr CRSSparsity' -> CDouble -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix'''''''
  :: CRSSparsity -> Double -> IO DMatrix
casADi__Matrix_double___DMatrix''''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix''''''' :: CRSSparsity -> Double -> IO DMatrix
dmatrix''''''' = casADi__Matrix_double___DMatrix'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr CRSSparsity' -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix''''''''
  :: CRSSparsity -> IO DMatrix
casADi__Matrix_double___DMatrix'''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix'''''''' :: CRSSparsity -> IO DMatrix
dmatrix'''''''' = casADi__Matrix_double___DMatrix''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr CRSSparsity' -> Ptr (CppVec CDouble) -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix'''''''''
  :: CRSSparsity -> Vector Double -> IO DMatrix
casADi__Matrix_double___DMatrix''''''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix''''''''' :: CRSSparsity -> Vector Double -> IO DMatrix
dmatrix''''''''' = casADi__Matrix_double___DMatrix'''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: CDouble -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix''''''''''
  :: Double -> IO DMatrix
casADi__Matrix_double___DMatrix'''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix'''''''''' :: Double -> IO DMatrix
dmatrix'''''''''' = casADi__Matrix_double___DMatrix''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CDouble) -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix'''''''''''
  :: Vector Double -> IO DMatrix
casADi__Matrix_double___DMatrix''''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix''''''''''' :: Vector Double -> IO DMatrix
dmatrix''''''''''' = casADi__Matrix_double___DMatrix'''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CDouble) -> CInt -> CInt -> IO (Ptr DMatrix')
casADi__Matrix_double___DMatrix''''''''''''
  :: Vector Double -> Int -> Int -> IO DMatrix
casADi__Matrix_double___DMatrix'''''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn

-- classy wrapper
dmatrix'''''''''''' :: Vector Double -> Int -> Int -> IO DMatrix
dmatrix'''''''''''' = casADi__Matrix_double___DMatrix''''''''''''