Sparsity.hs

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

module Casadi.Core.Classes.Sparsity
       (
         Sparsity,
         SparsityClass(..),
         sparsity_T,
         sparsity__0,
         sparsity__1,
         sparsity__2,
         sparsity__3,
         sparsity_addNZ,
         sparsity_append,
         sparsity_appendColumns,
         sparsity_band,
         sparsity_banded,
         sparsity_bandwidthL,
         sparsity_bandwidthU,
         sparsity_clearCache,
         sparsity_colind,
         sparsity_compress,
         sparsity_compressed,
         sparsity_dense__0,
         sparsity_dense__1,
         sparsity_depthFirstSearch,
         sparsity_diag__0,
         sparsity_diag__1,
         sparsity_dimString,
         sparsity_dulmageMendelsohn__0,
         sparsity_dulmageMendelsohn__1,
         sparsity_eliminationTree__0,
         sparsity_eliminationTree__1,
         sparsity_enlargeColumns__0,
         sparsity_enlargeColumns__1,
         sparsity_enlargeRows__0,
         sparsity_enlargeRows__1,
         sparsity_enlarge__0,
         sparsity_enlarge__1,
         sparsity_erase__0,
         sparsity_erase__1,
         sparsity_erase__2,
         sparsity_erase__3,
         sparsity_find__0,
         sparsity_find__1,
         sparsity_getCCS,
         sparsity_getCRS,
         sparsity_getCol,
         sparsity_getColind,
         sparsity_getDiag,
         sparsity_getLowerNZ,
         sparsity_getNZ__0,
         sparsity_getNZ__1,
         sparsity_getNZ__2,
         sparsity_getRow,
         sparsity_getTriplet,
         sparsity_getUpperNZ,
         sparsity_hasNZ,
         sparsity_hash,
         sparsity_isDense,
         sparsity_isDiagonal,
         sparsity_isEmpty__0,
         sparsity_isEmpty__1,
         sparsity_isEqual__0,
         sparsity_isEqual__1,
         sparsity_isReshape,
         sparsity_isScalar__0,
         sparsity_isScalar__1,
         sparsity_isSingular,
         sparsity_isSquare,
         sparsity_isSymmetric,
         sparsity_isTranspose,
         sparsity_isTril,
         sparsity_isTriu,
         sparsity_isVector__0,
         sparsity_isVector__1,
         sparsity_largestFirstOrdering,
         sparsity_lower,
         sparsity_makeDense,
         sparsity_nnz,
         sparsity_numel,
         sparsity_operator_equals,
         sparsity_operator_mul,
         sparsity_operator_nequals,
         sparsity_operator_plus,
         sparsity_patternCombine__0,
         sparsity_patternCombine__1,
         sparsity_patternIntersection__0,
         sparsity_patternIntersection__1,
         sparsity_patternInverse,
         sparsity_patternProduct,
         sparsity_patternUnion__0,
         sparsity_patternUnion__1,
         sparsity_pmult__0,
         sparsity_pmult__1,
         sparsity_pmult__2,
         sparsity_pmult__3,
         sparsity_printCompact,
         sparsity_reCache,
         sparsity_removeDuplicates,
         sparsity_reserve,
         sparsity_resize,
         sparsity_row,
         sparsity_rowcol,
         sparsity_rowsSequential__0,
         sparsity_rowsSequential__1,
         sparsity_sanityCheck__0,
         sparsity_sanityCheck__1,
         sparsity_scalar__0,
         sparsity_scalar__1,
         sparsity_size,
         sparsity_size1,
         sparsity_size2,
         sparsity_sizeD,
         sparsity_sizeL,
         sparsity_sizeU,
         sparsity_sparse__0,
         sparsity_sparse__1,
         sparsity_spy,
         sparsity_spyMatlab,
         sparsity_starColoring2__0,
         sparsity_starColoring2__1,
         sparsity_starColoring2__2,
         sparsity_starColoring__0,
         sparsity_starColoring__1,
         sparsity_starColoring__2,
         sparsity_stronglyConnectedComponents,
         sparsity_sub__0,
         sparsity_sub__1,
         sparsity_sub__2,
         sparsity_sub__3,
         sparsity_transpose__0,
         sparsity_transpose__1,
         sparsity_triplet__0,
         sparsity_triplet__1,
         sparsity_triplet__2,
         sparsity_unidirectionalColoring__0,
         sparsity_unidirectionalColoring__1,
         sparsity_unidirectionalColoring__2,
         sparsity_unit,
         sparsity_upper,
         sparsity_zz_blockcat,
         sparsity_zz_blocksplit,
         sparsity_zz_diagcat,
         sparsity_zz_diagsplit,
         sparsity_zz_horzcat,
         sparsity_zz_horzsplit,
         sparsity_zz_kron,
         sparsity_zz_mtimes__0,
         sparsity_zz_mtimes__1,
         sparsity_zz_norm_0_mul,
         sparsity_zz_repmat__0,
         sparsity_zz_repmat__1,
         sparsity_zz_reshape__0,
         sparsity_zz_reshape__1,
         sparsity_zz_sprank,
         sparsity_zz_tril__0,
         sparsity_zz_tril__1,
         sparsity_zz_triu__0,
         sparsity_zz_triu__1,
         sparsity_zz_vec,
         sparsity_zz_vecNZ,
         sparsity_zz_vecNZcat,
         sparsity_zz_veccat,
         sparsity_zz_vertcat,
         sparsity_zz_vertsplit,
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Marshal ( new, free )
import Foreign.Storable ( peek )
import Foreign.Ptr ( Ptr, nullPtr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
import Casadi.Internal.WrapReturn ( WrapReturn(..) )
import Casadi.Core.Data
import Casadi.Core.Enums
-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__0" c_casadi__Sparsity__CONSTRUCTOR__0
  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__CONSTRUCTOR__0
  :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
casadi__Sparsity__CONSTRUCTOR__0 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
sparsity__0 = casadi__Sparsity__CONSTRUCTOR__0


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__1" c_casadi__Sparsity__CONSTRUCTOR__1
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__CONSTRUCTOR__1
  :: Int -> Int -> IO Sparsity
casadi__Sparsity__CONSTRUCTOR__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__CONSTRUCTOR__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity__1 :: Int -> Int -> IO Sparsity
sparsity__1 = casadi__Sparsity__CONSTRUCTOR__1


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__2" c_casadi__Sparsity__CONSTRUCTOR__2
  :: Ptr (Ptr StdString) -> IO (Ptr Sparsity')
casadi__Sparsity__CONSTRUCTOR__2
  :: IO Sparsity
casadi__Sparsity__CONSTRUCTOR__2  =

  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__CONSTRUCTOR__2 errStrPtrP 
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity__2 :: IO Sparsity
sparsity__2 = casadi__Sparsity__CONSTRUCTOR__2


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__3" c_casadi__Sparsity__CONSTRUCTOR__3
  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__CONSTRUCTOR__3
  :: Int -> IO Sparsity
casadi__Sparsity__CONSTRUCTOR__3 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__CONSTRUCTOR__3 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity__3 :: Int -> IO Sparsity
sparsity__3 = casadi__Sparsity__CONSTRUCTOR__3


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__T" c_casadi__Sparsity__T
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__T
  :: Sparsity -> IO Sparsity
casadi__Sparsity__T x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__T errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_T :: SparsityClass a => a -> IO Sparsity
sparsity_T x = casadi__Sparsity__T (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__addNZ" c_casadi__Sparsity__addNZ
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
casadi__Sparsity__addNZ
  :: Sparsity -> Int -> Int -> IO Int
casadi__Sparsity__addNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__addNZ errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_addNZ :: SparsityClass a => a -> Int -> Int -> IO Int
sparsity_addNZ x = casadi__Sparsity__addNZ (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__append" c_casadi__Sparsity__append
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO ()
casadi__Sparsity__append
  :: Sparsity -> Sparsity -> IO ()
casadi__Sparsity__append x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__append errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_append :: SparsityClass a => a -> Sparsity -> IO ()
sparsity_append x = casadi__Sparsity__append (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__appendColumns" c_casadi__Sparsity__appendColumns
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO ()
casadi__Sparsity__appendColumns
  :: Sparsity -> Sparsity -> IO ()
casadi__Sparsity__appendColumns x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__appendColumns errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_appendColumns :: SparsityClass a => a -> Sparsity -> IO ()
sparsity_appendColumns x = casadi__Sparsity__appendColumns (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__band" c_casadi__Sparsity__band
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__band
  :: Int -> Int -> IO Sparsity
casadi__Sparsity__band x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__band errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_band :: Int -> Int -> IO Sparsity
sparsity_band = casadi__Sparsity__band


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__banded" c_casadi__Sparsity__banded
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__banded
  :: Int -> Int -> IO Sparsity
casadi__Sparsity__banded x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__banded errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_banded :: Int -> Int -> IO Sparsity
sparsity_banded = casadi__Sparsity__banded


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__bandwidthL" c_casadi__Sparsity__bandwidthL
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__bandwidthL
  :: Sparsity -> IO Int
casadi__Sparsity__bandwidthL x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__bandwidthL errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_bandwidthL :: SparsityClass a => a -> IO Int
sparsity_bandwidthL x = casadi__Sparsity__bandwidthL (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__bandwidthU" c_casadi__Sparsity__bandwidthU
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__bandwidthU
  :: Sparsity -> IO Int
casadi__Sparsity__bandwidthU x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__bandwidthU errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_bandwidthU :: SparsityClass a => a -> IO Int
sparsity_bandwidthU x = casadi__Sparsity__bandwidthU (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__clearCache" c_casadi__Sparsity__clearCache
  :: Ptr (Ptr StdString) -> IO ()
casadi__Sparsity__clearCache
  :: IO ()
casadi__Sparsity__clearCache  =

  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__clearCache errStrPtrP 
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_clearCache :: IO ()
sparsity_clearCache = casadi__Sparsity__clearCache


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__colind" c_casadi__Sparsity__colind
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
casadi__Sparsity__colind
  :: Sparsity -> Int -> IO Int
casadi__Sparsity__colind x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__colind errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_colind :: SparsityClass a => a -> Int -> IO Int
sparsity_colind x = casadi__Sparsity__colind (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__compress" c_casadi__Sparsity__compress
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__compress
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__compress x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__compress errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_compress :: SparsityClass a => a -> IO (Vector Int)
sparsity_compress x = casadi__Sparsity__compress (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__compressed" c_casadi__Sparsity__compressed
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__compressed
  :: Vector Int -> IO Sparsity
casadi__Sparsity__compressed x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__compressed errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_compressed :: Vector Int -> IO Sparsity
sparsity_compressed = casadi__Sparsity__compressed


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__dense__0" c_casadi__Sparsity__dense__0
  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__dense__0
  :: Int -> IO Sparsity
casadi__Sparsity__dense__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__dense__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_dense__0 :: Int -> IO Sparsity
sparsity_dense__0 = casadi__Sparsity__dense__0


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__dense__1" c_casadi__Sparsity__dense__1
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__dense__1
  :: Int -> Int -> IO Sparsity
casadi__Sparsity__dense__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__dense__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_dense__1 :: Int -> Int -> IO Sparsity
sparsity_dense__1 = casadi__Sparsity__dense__1


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__depthFirstSearch" c_casadi__Sparsity__depthFirstSearch
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
casadi__Sparsity__depthFirstSearch
  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int
casadi__Sparsity__depthFirstSearch x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__depthFirstSearch errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_depthFirstSearch :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int
sparsity_depthFirstSearch x = casadi__Sparsity__depthFirstSearch (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__diag__0" c_casadi__Sparsity__diag__0
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__diag__0
  :: Int -> Int -> IO Sparsity
casadi__Sparsity__diag__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__diag__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_diag__0 :: Int -> Int -> IO Sparsity
sparsity_diag__0 = casadi__Sparsity__diag__0


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__diag__1" c_casadi__Sparsity__diag__1
  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__diag__1
  :: Int -> IO Sparsity
casadi__Sparsity__diag__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__diag__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_diag__1 :: Int -> IO Sparsity
sparsity_diag__1 = casadi__Sparsity__diag__1


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__dimString" c_casadi__Sparsity__dimString
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr StdString)
casadi__Sparsity__dimString
  :: Sparsity -> IO String
casadi__Sparsity__dimString x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__dimString errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_dimString :: SparsityClass a => a -> IO String
sparsity_dimString x = casadi__Sparsity__dimString (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__dulmageMendelsohn__0" c_casadi__Sparsity__dulmageMendelsohn__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
casadi__Sparsity__dulmageMendelsohn__0
  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> IO Int
casadi__Sparsity__dulmageMendelsohn__0 x0 x1 x2 x3 x4 x5 x6 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__dulmageMendelsohn__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_dulmageMendelsohn__0 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> IO Int
sparsity_dulmageMendelsohn__0 x = casadi__Sparsity__dulmageMendelsohn__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__dulmageMendelsohn__1" c_casadi__Sparsity__dulmageMendelsohn__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO CInt
casadi__Sparsity__dulmageMendelsohn__1
  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Int -> IO Int
casadi__Sparsity__dulmageMendelsohn__1 x0 x1 x2 x3 x4 x5 x6 x7 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  withMarshal x6 $ \x6' ->
  withMarshal x7 $ \x7' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__dulmageMendelsohn__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_dulmageMendelsohn__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Int -> IO Int
sparsity_dulmageMendelsohn__1 x = casadi__Sparsity__dulmageMendelsohn__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__eliminationTree__0" c_casadi__Sparsity__eliminationTree__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__eliminationTree__0
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__eliminationTree__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__eliminationTree__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_eliminationTree__0 :: SparsityClass a => a -> IO (Vector Int)
sparsity_eliminationTree__0 x = casadi__Sparsity__eliminationTree__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__eliminationTree__1" c_casadi__Sparsity__eliminationTree__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt))
casadi__Sparsity__eliminationTree__1
  :: Sparsity -> Bool -> IO (Vector Int)
casadi__Sparsity__eliminationTree__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__eliminationTree__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_eliminationTree__1 :: SparsityClass a => a -> Bool -> IO (Vector Int)
sparsity_eliminationTree__1 x = casadi__Sparsity__eliminationTree__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__enlarge__0" c_casadi__Sparsity__enlarge__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__enlarge__0
  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casadi__Sparsity__enlarge__0 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__enlarge__0 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_enlarge__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
sparsity_enlarge__0 x = casadi__Sparsity__enlarge__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__enlarge__1" c_casadi__Sparsity__enlarge__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
casadi__Sparsity__enlarge__1
  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
casadi__Sparsity__enlarge__1 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_enlarge__1 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
sparsity_enlarge__1 x = casadi__Sparsity__enlarge__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__0" c_casadi__Sparsity__enlargeColumns__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__enlargeColumns__0
  :: Sparsity -> Int -> Vector Int -> IO ()
casadi__Sparsity__enlargeColumns__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__enlargeColumns__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_enlargeColumns__0 :: SparsityClass a => a -> Int -> Vector Int -> IO ()
sparsity_enlargeColumns__0 x = casadi__Sparsity__enlargeColumns__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__1" c_casadi__Sparsity__enlargeColumns__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO ()
casadi__Sparsity__enlargeColumns__1
  :: Sparsity -> Int -> Vector Int -> Bool -> IO ()
casadi__Sparsity__enlargeColumns__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__enlargeColumns__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_enlargeColumns__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO ()
sparsity_enlargeColumns__1 x = casadi__Sparsity__enlargeColumns__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__enlargeRows__0" c_casadi__Sparsity__enlargeRows__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__enlargeRows__0
  :: Sparsity -> Int -> Vector Int -> IO ()
casadi__Sparsity__enlargeRows__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__enlargeRows__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_enlargeRows__0 :: SparsityClass a => a -> Int -> Vector Int -> IO ()
sparsity_enlargeRows__0 x = casadi__Sparsity__enlargeRows__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__enlargeRows__1" c_casadi__Sparsity__enlargeRows__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO ()
casadi__Sparsity__enlargeRows__1
  :: Sparsity -> Int -> Vector Int -> Bool -> IO ()
casadi__Sparsity__enlargeRows__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__enlargeRows__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_enlargeRows__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO ()
sparsity_enlargeRows__1 x = casadi__Sparsity__enlargeRows__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__erase__0" c_casadi__Sparsity__erase__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
casadi__Sparsity__erase__0
  :: Sparsity -> Vector Int -> IO (Vector Int)
casadi__Sparsity__erase__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__erase__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_erase__0 :: SparsityClass a => a -> Vector Int -> IO (Vector Int)
sparsity_erase__0 x = casadi__Sparsity__erase__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__erase__1" c_casadi__Sparsity__erase__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
casadi__Sparsity__erase__1
  :: Sparsity -> Vector Int -> Bool -> IO (Vector Int)
casadi__Sparsity__erase__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__erase__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_erase__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO (Vector Int)
sparsity_erase__1 x = casadi__Sparsity__erase__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__erase__2" c_casadi__Sparsity__erase__2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
casadi__Sparsity__erase__2
  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int)
casadi__Sparsity__erase__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__erase__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_erase__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)
sparsity_erase__2 x = casadi__Sparsity__erase__2 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__erase__3" c_casadi__Sparsity__erase__3
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt))
casadi__Sparsity__erase__3
  :: Sparsity -> Vector Int -> Vector Int -> Bool -> IO (Vector Int)
casadi__Sparsity__erase__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__erase__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_erase__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Bool -> IO (Vector Int)
sparsity_erase__3 x = casadi__Sparsity__erase__3 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__find__0" c_casadi__Sparsity__find__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__find__0
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__find__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__find__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_find__0 :: SparsityClass a => a -> IO (Vector Int)
sparsity_find__0 x = casadi__Sparsity__find__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__find__1" c_casadi__Sparsity__find__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt))
casadi__Sparsity__find__1
  :: Sparsity -> Bool -> IO (Vector Int)
casadi__Sparsity__find__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__find__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_find__1 :: SparsityClass a => a -> Bool -> IO (Vector Int)
sparsity_find__1 x = casadi__Sparsity__find__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getCCS" c_casadi__Sparsity__getCCS
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__getCCS
  :: Sparsity -> Vector Int -> Vector Int -> IO ()
casadi__Sparsity__getCCS x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getCCS errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getCCS :: SparsityClass a => a -> Vector Int -> Vector Int -> IO ()
sparsity_getCCS x = casadi__Sparsity__getCCS (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getCRS" c_casadi__Sparsity__getCRS
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__getCRS
  :: Sparsity -> Vector Int -> Vector Int -> IO ()
casadi__Sparsity__getCRS x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getCRS errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getCRS :: SparsityClass a => a -> Vector Int -> Vector Int -> IO ()
sparsity_getCRS x = casadi__Sparsity__getCRS (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getCol" c_casadi__Sparsity__getCol
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__getCol
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__getCol x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getCol errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getCol :: SparsityClass a => a -> IO (Vector Int)
sparsity_getCol x = casadi__Sparsity__getCol (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getColind" c_casadi__Sparsity__getColind
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__getColind
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__getColind x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getColind errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getColind :: SparsityClass a => a -> IO (Vector Int)
sparsity_getColind x = casadi__Sparsity__getColind (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getDiag" c_casadi__Sparsity__getDiag
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__getDiag
  :: Sparsity -> Vector Int -> IO Sparsity
casadi__Sparsity__getDiag x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getDiag errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getDiag :: SparsityClass a => a -> Vector Int -> IO Sparsity
sparsity_getDiag x = casadi__Sparsity__getDiag (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getLowerNZ" c_casadi__Sparsity__getLowerNZ
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__getLowerNZ
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__getLowerNZ x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getLowerNZ errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getLowerNZ :: SparsityClass a => a -> IO (Vector Int)
sparsity_getLowerNZ x = casadi__Sparsity__getLowerNZ (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getNZ__0" c_casadi__Sparsity__getNZ__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__getNZ__0
  :: Sparsity -> Vector Int -> IO ()
casadi__Sparsity__getNZ__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getNZ__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getNZ__0 :: SparsityClass a => a -> Vector Int -> IO ()
sparsity_getNZ__0 x = casadi__Sparsity__getNZ__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getNZ__1" c_casadi__Sparsity__getNZ__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
casadi__Sparsity__getNZ__1
  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int)
casadi__Sparsity__getNZ__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getNZ__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getNZ__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)
sparsity_getNZ__1 x = casadi__Sparsity__getNZ__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getNZ__2" c_casadi__Sparsity__getNZ__2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
casadi__Sparsity__getNZ__2
  :: Sparsity -> Int -> Int -> IO Int
casadi__Sparsity__getNZ__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getNZ__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getNZ__2 :: SparsityClass a => a -> Int -> Int -> IO Int
sparsity_getNZ__2 x = casadi__Sparsity__getNZ__2 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getRow" c_casadi__Sparsity__getRow
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__getRow
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__getRow x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getRow errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getRow :: SparsityClass a => a -> IO (Vector Int)
sparsity_getRow x = casadi__Sparsity__getRow (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getTriplet" c_casadi__Sparsity__getTriplet
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__getTriplet
  :: Sparsity -> Vector Int -> Vector Int -> IO ()
casadi__Sparsity__getTriplet x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getTriplet errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getTriplet :: SparsityClass a => a -> Vector Int -> Vector Int -> IO ()
sparsity_getTriplet x = casadi__Sparsity__getTriplet (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__getUpperNZ" c_casadi__Sparsity__getUpperNZ
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__getUpperNZ
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__getUpperNZ x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getUpperNZ errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getUpperNZ :: SparsityClass a => a -> IO (Vector Int)
sparsity_getUpperNZ x = casadi__Sparsity__getUpperNZ (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__hasNZ" c_casadi__Sparsity__hasNZ
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt
casadi__Sparsity__hasNZ
  :: Sparsity -> Int -> Int -> IO Bool
casadi__Sparsity__hasNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__hasNZ errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_hasNZ :: SparsityClass a => a -> Int -> Int -> IO Bool
sparsity_hasNZ x = casadi__Sparsity__hasNZ (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__hash" c_casadi__Sparsity__hash
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CSize
casadi__Sparsity__hash
  :: Sparsity -> IO CSize
casadi__Sparsity__hash x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__hash errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_hash :: SparsityClass a => a -> IO CSize
sparsity_hash x = casadi__Sparsity__hash (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isDense" c_casadi__Sparsity__isDense
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isDense
  :: Sparsity -> IO Bool
casadi__Sparsity__isDense x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isDense errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isDense :: SparsityClass a => a -> IO Bool
sparsity_isDense x = casadi__Sparsity__isDense (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isDiagonal" c_casadi__Sparsity__isDiagonal
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isDiagonal
  :: Sparsity -> IO Bool
casadi__Sparsity__isDiagonal x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isDiagonal errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isDiagonal :: SparsityClass a => a -> IO Bool
sparsity_isDiagonal x = casadi__Sparsity__isDiagonal (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isEmpty__0" c_casadi__Sparsity__isEmpty__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isEmpty__0
  :: Sparsity -> IO Bool
casadi__Sparsity__isEmpty__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isEmpty__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isEmpty__0 :: SparsityClass a => a -> IO Bool
sparsity_isEmpty__0 x = casadi__Sparsity__isEmpty__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isEmpty__1" c_casadi__Sparsity__isEmpty__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
casadi__Sparsity__isEmpty__1
  :: Sparsity -> Bool -> IO Bool
casadi__Sparsity__isEmpty__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isEmpty__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isEmpty__1 :: SparsityClass a => a -> Bool -> IO Bool
sparsity_isEmpty__1 x = casadi__Sparsity__isEmpty__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isEqual__0" c_casadi__Sparsity__isEqual__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
casadi__Sparsity__isEqual__0
  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO Bool
casadi__Sparsity__isEqual__0 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isEqual__0 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isEqual__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO Bool
sparsity_isEqual__0 x = casadi__Sparsity__isEqual__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isEqual__1" c_casadi__Sparsity__isEqual__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isEqual__1
  :: Sparsity -> Sparsity -> IO Bool
casadi__Sparsity__isEqual__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isEqual__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isEqual__1 :: SparsityClass a => a -> Sparsity -> IO Bool
sparsity_isEqual__1 x = casadi__Sparsity__isEqual__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isReshape" c_casadi__Sparsity__isReshape
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isReshape
  :: Sparsity -> Sparsity -> IO Bool
casadi__Sparsity__isReshape x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isReshape errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isReshape :: SparsityClass a => a -> Sparsity -> IO Bool
sparsity_isReshape x = casadi__Sparsity__isReshape (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isScalar__0" c_casadi__Sparsity__isScalar__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isScalar__0
  :: Sparsity -> IO Bool
casadi__Sparsity__isScalar__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isScalar__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isScalar__0 :: SparsityClass a => a -> IO Bool
sparsity_isScalar__0 x = casadi__Sparsity__isScalar__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isScalar__1" c_casadi__Sparsity__isScalar__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
casadi__Sparsity__isScalar__1
  :: Sparsity -> Bool -> IO Bool
casadi__Sparsity__isScalar__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isScalar__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isScalar__1 :: SparsityClass a => a -> Bool -> IO Bool
sparsity_isScalar__1 x = casadi__Sparsity__isScalar__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isSingular" c_casadi__Sparsity__isSingular
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isSingular
  :: Sparsity -> IO Bool
casadi__Sparsity__isSingular x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isSingular errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isSingular :: SparsityClass a => a -> IO Bool
sparsity_isSingular x = casadi__Sparsity__isSingular (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isSquare" c_casadi__Sparsity__isSquare
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isSquare
  :: Sparsity -> IO Bool
casadi__Sparsity__isSquare x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isSquare errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isSquare :: SparsityClass a => a -> IO Bool
sparsity_isSquare x = casadi__Sparsity__isSquare (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isSymmetric" c_casadi__Sparsity__isSymmetric
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isSymmetric
  :: Sparsity -> IO Bool
casadi__Sparsity__isSymmetric x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isSymmetric errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isSymmetric :: SparsityClass a => a -> IO Bool
sparsity_isSymmetric x = casadi__Sparsity__isSymmetric (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isTranspose" c_casadi__Sparsity__isTranspose
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isTranspose
  :: Sparsity -> Sparsity -> IO Bool
casadi__Sparsity__isTranspose x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isTranspose errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isTranspose :: SparsityClass a => a -> Sparsity -> IO Bool
sparsity_isTranspose x = casadi__Sparsity__isTranspose (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isTril" c_casadi__Sparsity__isTril
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isTril
  :: Sparsity -> IO Bool
casadi__Sparsity__isTril x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isTril errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isTril :: SparsityClass a => a -> IO Bool
sparsity_isTril x = casadi__Sparsity__isTril (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isTriu" c_casadi__Sparsity__isTriu
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isTriu
  :: Sparsity -> IO Bool
casadi__Sparsity__isTriu x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isTriu errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isTriu :: SparsityClass a => a -> IO Bool
sparsity_isTriu x = casadi__Sparsity__isTriu (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isVector__0" c_casadi__Sparsity__isVector__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isVector__0
  :: Sparsity -> IO Bool
casadi__Sparsity__isVector__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isVector__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isVector__0 :: SparsityClass a => a -> IO Bool
sparsity_isVector__0 x = casadi__Sparsity__isVector__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__isVector__1" c_casadi__Sparsity__isVector__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
casadi__Sparsity__isVector__1
  :: Sparsity -> Bool -> IO Bool
casadi__Sparsity__isVector__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isVector__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isVector__1 :: SparsityClass a => a -> Bool -> IO Bool
sparsity_isVector__1 x = casadi__Sparsity__isVector__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__largestFirstOrdering" c_casadi__Sparsity__largestFirstOrdering
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt))
casadi__Sparsity__largestFirstOrdering
  :: Sparsity -> IO (Vector Int)
casadi__Sparsity__largestFirstOrdering x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__largestFirstOrdering errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_largestFirstOrdering :: SparsityClass a => a -> IO (Vector Int)
sparsity_largestFirstOrdering x = casadi__Sparsity__largestFirstOrdering (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__lower" c_casadi__Sparsity__lower
  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__lower
  :: Int -> IO Sparsity
casadi__Sparsity__lower x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__lower errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_lower :: Int -> IO Sparsity
sparsity_lower = casadi__Sparsity__lower


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__makeDense" c_casadi__Sparsity__makeDense
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__makeDense
  :: Sparsity -> Vector Int -> IO Sparsity
casadi__Sparsity__makeDense x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__makeDense errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_makeDense :: SparsityClass a => a -> Vector Int -> IO Sparsity
sparsity_makeDense x = casadi__Sparsity__makeDense (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__nnz" c_casadi__Sparsity__nnz
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__nnz
  :: Sparsity -> IO Int
casadi__Sparsity__nnz x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__nnz errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_nnz :: SparsityClass a => a -> IO Int
sparsity_nnz x = casadi__Sparsity__nnz (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__numel" c_casadi__Sparsity__numel
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__numel
  :: Sparsity -> IO Int
casadi__Sparsity__numel x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__numel errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_numel :: SparsityClass a => a -> IO Int
sparsity_numel x = casadi__Sparsity__numel (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__operator_nequals" c_casadi__Sparsity__operator_nequals
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__operator_nequals
  :: Sparsity -> Sparsity -> IO Bool
casadi__Sparsity__operator_nequals x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__operator_nequals errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_operator_nequals :: SparsityClass a => a -> Sparsity -> IO Bool
sparsity_operator_nequals x = casadi__Sparsity__operator_nequals (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__operator_mul" c_casadi__Sparsity__operator_mul
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__operator_mul
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__operator_mul x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__operator_mul errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_operator_mul :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_operator_mul x = casadi__Sparsity__operator_mul (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__operator_plus" c_casadi__Sparsity__operator_plus
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__operator_plus
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__operator_plus x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__operator_plus errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_operator_plus :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_operator_plus x = casadi__Sparsity__operator_plus (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__operator_equals" c_casadi__Sparsity__operator_equals
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__operator_equals
  :: Sparsity -> Sparsity -> IO Bool
casadi__Sparsity__operator_equals x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__operator_equals errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_operator_equals :: SparsityClass a => a -> Sparsity -> IO Bool
sparsity_operator_equals x = casadi__Sparsity__operator_equals (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__patternCombine__0" c_casadi__Sparsity__patternCombine__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__patternCombine__0
  :: Sparsity -> Sparsity -> Bool -> Bool -> IO Sparsity
casadi__Sparsity__patternCombine__0 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternCombine__0 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternCombine__0 :: SparsityClass a => a -> Sparsity -> Bool -> Bool -> IO Sparsity
sparsity_patternCombine__0 x = casadi__Sparsity__patternCombine__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__patternCombine__1" c_casadi__Sparsity__patternCombine__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CUChar) -> IO (Ptr Sparsity')
casadi__Sparsity__patternCombine__1
  :: Sparsity -> Sparsity -> Bool -> Bool -> Vector CUChar -> IO Sparsity
casadi__Sparsity__patternCombine__1 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternCombine__1 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternCombine__1 :: SparsityClass a => a -> Sparsity -> Bool -> Bool -> Vector CUChar -> IO Sparsity
sparsity_patternCombine__1 x = casadi__Sparsity__patternCombine__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__patternIntersection__0" c_casadi__Sparsity__patternIntersection__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__patternIntersection__0
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__patternIntersection__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternIntersection__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternIntersection__0 :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_patternIntersection__0 x = casadi__Sparsity__patternIntersection__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__patternIntersection__1" c_casadi__Sparsity__patternIntersection__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr (StdVec CUChar) -> IO (Ptr Sparsity')
casadi__Sparsity__patternIntersection__1
  :: Sparsity -> Sparsity -> Vector CUChar -> IO Sparsity
casadi__Sparsity__patternIntersection__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternIntersection__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternIntersection__1 :: SparsityClass a => a -> Sparsity -> Vector CUChar -> IO Sparsity
sparsity_patternIntersection__1 x = casadi__Sparsity__patternIntersection__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__patternInverse" c_casadi__Sparsity__patternInverse
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__patternInverse
  :: Sparsity -> IO Sparsity
casadi__Sparsity__patternInverse x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternInverse errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternInverse :: SparsityClass a => a -> IO Sparsity
sparsity_patternInverse x = casadi__Sparsity__patternInverse (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__patternProduct" c_casadi__Sparsity__patternProduct
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__patternProduct
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__patternProduct x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternProduct errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternProduct :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_patternProduct x = casadi__Sparsity__patternProduct (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__patternUnion__0" c_casadi__Sparsity__patternUnion__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__patternUnion__0
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__patternUnion__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternUnion__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternUnion__0 :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_patternUnion__0 x = casadi__Sparsity__patternUnion__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__patternUnion__1" c_casadi__Sparsity__patternUnion__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr (StdVec CUChar) -> IO (Ptr Sparsity')
casadi__Sparsity__patternUnion__1
  :: Sparsity -> Sparsity -> Vector CUChar -> IO Sparsity
casadi__Sparsity__patternUnion__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternUnion__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternUnion__1 :: SparsityClass a => a -> Sparsity -> Vector CUChar -> IO Sparsity
sparsity_patternUnion__1 x = casadi__Sparsity__patternUnion__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__pmult__0" c_casadi__Sparsity__pmult__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__pmult__0
  :: Sparsity -> Vector Int -> IO Sparsity
casadi__Sparsity__pmult__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__pmult__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_pmult__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity
sparsity_pmult__0 x = casadi__Sparsity__pmult__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__pmult__1" c_casadi__Sparsity__pmult__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__pmult__1
  :: Sparsity -> Vector Int -> Bool -> IO Sparsity
casadi__Sparsity__pmult__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__pmult__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_pmult__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity
sparsity_pmult__1 x = casadi__Sparsity__pmult__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__pmult__2" c_casadi__Sparsity__pmult__2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__pmult__2
  :: Sparsity -> Vector Int -> Bool -> Bool -> IO Sparsity
casadi__Sparsity__pmult__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__pmult__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_pmult__2 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> IO Sparsity
sparsity_pmult__2 x = casadi__Sparsity__pmult__2 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__pmult__3" c_casadi__Sparsity__pmult__3
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__pmult__3
  :: Sparsity -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity
casadi__Sparsity__pmult__3 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__pmult__3 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_pmult__3 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity
sparsity_pmult__3 x = casadi__Sparsity__pmult__3 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__printCompact" c_casadi__Sparsity__printCompact
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
casadi__Sparsity__printCompact
  :: Sparsity -> IO ()
casadi__Sparsity__printCompact x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__printCompact errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_printCompact :: SparsityClass a => a -> IO ()
sparsity_printCompact x = casadi__Sparsity__printCompact (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__reCache" c_casadi__Sparsity__reCache
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
casadi__Sparsity__reCache
  :: Sparsity -> IO ()
casadi__Sparsity__reCache x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__reCache errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_reCache :: SparsityClass a => a -> IO ()
sparsity_reCache x = casadi__Sparsity__reCache (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__removeDuplicates" c_casadi__Sparsity__removeDuplicates
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__removeDuplicates
  :: Sparsity -> Vector Int -> IO ()
casadi__Sparsity__removeDuplicates x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__removeDuplicates errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_removeDuplicates :: SparsityClass a => a -> Vector Int -> IO ()
sparsity_removeDuplicates x = casadi__Sparsity__removeDuplicates (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__reserve" c_casadi__Sparsity__reserve
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO ()
casadi__Sparsity__reserve
  :: Sparsity -> Int -> Int -> IO ()
casadi__Sparsity__reserve x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__reserve errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_reserve :: SparsityClass a => a -> Int -> Int -> IO ()
sparsity_reserve x = casadi__Sparsity__reserve (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__resize" c_casadi__Sparsity__resize
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO ()
casadi__Sparsity__resize
  :: Sparsity -> Int -> Int -> IO ()
casadi__Sparsity__resize x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__resize errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_resize :: SparsityClass a => a -> Int -> Int -> IO ()
sparsity_resize x = casadi__Sparsity__resize (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__row" c_casadi__Sparsity__row
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
casadi__Sparsity__row
  :: Sparsity -> Int -> IO Int
casadi__Sparsity__row x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__row errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_row :: SparsityClass a => a -> Int -> IO Int
sparsity_row x = casadi__Sparsity__row (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__rowcol" c_casadi__Sparsity__rowcol
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__rowcol
  :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity
casadi__Sparsity__rowcol x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__rowcol errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_rowcol :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity
sparsity_rowcol = casadi__Sparsity__rowcol


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__rowsSequential__0" c_casadi__Sparsity__rowsSequential__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__rowsSequential__0
  :: Sparsity -> IO Bool
casadi__Sparsity__rowsSequential__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__rowsSequential__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_rowsSequential__0 :: SparsityClass a => a -> IO Bool
sparsity_rowsSequential__0 x = casadi__Sparsity__rowsSequential__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__rowsSequential__1" c_casadi__Sparsity__rowsSequential__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
casadi__Sparsity__rowsSequential__1
  :: Sparsity -> Bool -> IO Bool
casadi__Sparsity__rowsSequential__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__rowsSequential__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_rowsSequential__1 :: SparsityClass a => a -> Bool -> IO Bool
sparsity_rowsSequential__1 x = casadi__Sparsity__rowsSequential__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sanityCheck__0" c_casadi__Sparsity__sanityCheck__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
casadi__Sparsity__sanityCheck__0
  :: Sparsity -> IO ()
casadi__Sparsity__sanityCheck__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sanityCheck__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sanityCheck__0 :: SparsityClass a => a -> IO ()
sparsity_sanityCheck__0 x = casadi__Sparsity__sanityCheck__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sanityCheck__1" c_casadi__Sparsity__sanityCheck__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO ()
casadi__Sparsity__sanityCheck__1
  :: Sparsity -> Bool -> IO ()
casadi__Sparsity__sanityCheck__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sanityCheck__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sanityCheck__1 :: SparsityClass a => a -> Bool -> IO ()
sparsity_sanityCheck__1 x = casadi__Sparsity__sanityCheck__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__scalar__0" c_casadi__Sparsity__scalar__0
  :: Ptr (Ptr StdString) -> IO (Ptr Sparsity')
casadi__Sparsity__scalar__0
  :: IO Sparsity
casadi__Sparsity__scalar__0  =

  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__scalar__0 errStrPtrP 
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_scalar__0 :: IO Sparsity
sparsity_scalar__0 = casadi__Sparsity__scalar__0


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__scalar__1" c_casadi__Sparsity__scalar__1
  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__scalar__1
  :: Bool -> IO Sparsity
casadi__Sparsity__scalar__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__scalar__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_scalar__1 :: Bool -> IO Sparsity
sparsity_scalar__1 = casadi__Sparsity__scalar__1


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__size" c_casadi__Sparsity__size
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__size
  :: Sparsity -> IO Int
casadi__Sparsity__size x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__size errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_size :: SparsityClass a => a -> IO Int
sparsity_size x = casadi__Sparsity__size (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__size1" c_casadi__Sparsity__size1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__size1
  :: Sparsity -> IO Int
casadi__Sparsity__size1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__size1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_size1 :: SparsityClass a => a -> IO Int
sparsity_size1 x = casadi__Sparsity__size1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__size2" c_casadi__Sparsity__size2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__size2
  :: Sparsity -> IO Int
casadi__Sparsity__size2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__size2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_size2 :: SparsityClass a => a -> IO Int
sparsity_size2 x = casadi__Sparsity__size2 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sizeD" c_casadi__Sparsity__sizeD
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__sizeD
  :: Sparsity -> IO Int
casadi__Sparsity__sizeD x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sizeD errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sizeD :: SparsityClass a => a -> IO Int
sparsity_sizeD x = casadi__Sparsity__sizeD (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sizeL" c_casadi__Sparsity__sizeL
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__sizeL
  :: Sparsity -> IO Int
casadi__Sparsity__sizeL x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sizeL errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sizeL :: SparsityClass a => a -> IO Int
sparsity_sizeL x = casadi__Sparsity__sizeL (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sizeU" c_casadi__Sparsity__sizeU
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__sizeU
  :: Sparsity -> IO Int
casadi__Sparsity__sizeU x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sizeU errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sizeU :: SparsityClass a => a -> IO Int
sparsity_sizeU x = casadi__Sparsity__sizeU (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sparse__0" c_casadi__Sparsity__sparse__0
  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__sparse__0
  :: Int -> IO Sparsity
casadi__Sparsity__sparse__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sparse__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sparse__0 :: Int -> IO Sparsity
sparsity_sparse__0 = casadi__Sparsity__sparse__0


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sparse__1" c_casadi__Sparsity__sparse__1
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__sparse__1
  :: Int -> Int -> IO Sparsity
casadi__Sparsity__sparse__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sparse__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sparse__1 :: Int -> Int -> IO Sparsity
sparsity_sparse__1 = casadi__Sparsity__sparse__1


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__spy" c_casadi__Sparsity__spy
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO ()
casadi__Sparsity__spy
  :: Sparsity -> IO ()
casadi__Sparsity__spy x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__spy errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_spy :: SparsityClass a => a -> IO ()
sparsity_spy x = casadi__Sparsity__spy (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__spyMatlab" c_casadi__Sparsity__spyMatlab
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr StdString -> IO ()
casadi__Sparsity__spyMatlab
  :: Sparsity -> String -> IO ()
casadi__Sparsity__spyMatlab x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__spyMatlab errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_spyMatlab :: SparsityClass a => a -> String -> IO ()
sparsity_spyMatlab x = casadi__Sparsity__spyMatlab (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__starColoring__0" c_casadi__Sparsity__starColoring__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__starColoring__0
  :: Sparsity -> IO Sparsity
casadi__Sparsity__starColoring__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__starColoring__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_starColoring__0 :: SparsityClass a => a -> IO Sparsity
sparsity_starColoring__0 x = casadi__Sparsity__starColoring__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__starColoring__1" c_casadi__Sparsity__starColoring__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__starColoring__1
  :: Sparsity -> Int -> IO Sparsity
casadi__Sparsity__starColoring__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__starColoring__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_starColoring__1 :: SparsityClass a => a -> Int -> IO Sparsity
sparsity_starColoring__1 x = casadi__Sparsity__starColoring__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__starColoring__2" c_casadi__Sparsity__starColoring__2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__starColoring__2
  :: Sparsity -> Int -> Int -> IO Sparsity
casadi__Sparsity__starColoring__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__starColoring__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_starColoring__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity
sparsity_starColoring__2 x = casadi__Sparsity__starColoring__2 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__starColoring2__0" c_casadi__Sparsity__starColoring2__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__starColoring2__0
  :: Sparsity -> IO Sparsity
casadi__Sparsity__starColoring2__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__starColoring2__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_starColoring2__0 :: SparsityClass a => a -> IO Sparsity
sparsity_starColoring2__0 x = casadi__Sparsity__starColoring2__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__starColoring2__1" c_casadi__Sparsity__starColoring2__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__starColoring2__1
  :: Sparsity -> Int -> IO Sparsity
casadi__Sparsity__starColoring2__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__starColoring2__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_starColoring2__1 :: SparsityClass a => a -> Int -> IO Sparsity
sparsity_starColoring2__1 x = casadi__Sparsity__starColoring2__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__starColoring2__2" c_casadi__Sparsity__starColoring2__2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__starColoring2__2
  :: Sparsity -> Int -> Int -> IO Sparsity
casadi__Sparsity__starColoring2__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__starColoring2__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_starColoring2__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity
sparsity_starColoring2__2 x = casadi__Sparsity__starColoring2__2 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__stronglyConnectedComponents" c_casadi__Sparsity__stronglyConnectedComponents
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
casadi__Sparsity__stronglyConnectedComponents
  :: Sparsity -> Vector Int -> Vector Int -> IO Int
casadi__Sparsity__stronglyConnectedComponents x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__stronglyConnectedComponents errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_stronglyConnectedComponents :: SparsityClass a => a -> Vector Int -> Vector Int -> IO Int
sparsity_stronglyConnectedComponents x = casadi__Sparsity__stronglyConnectedComponents (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sub__0" c_casadi__Sparsity__sub__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__sub__0
  :: Sparsity -> Vector Int -> Sparsity -> Vector Int -> IO Sparsity
casadi__Sparsity__sub__0 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sub__0 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sub__0 :: SparsityClass a => a -> Vector Int -> Sparsity -> Vector Int -> IO Sparsity
sparsity_sub__0 x = casadi__Sparsity__sub__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sub__1" c_casadi__Sparsity__sub__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__sub__1
  :: Sparsity -> Vector Int -> Sparsity -> Vector Int -> Bool -> IO Sparsity
casadi__Sparsity__sub__1 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sub__1 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sub__1 :: SparsityClass a => a -> Vector Int -> Sparsity -> Vector Int -> Bool -> IO Sparsity
sparsity_sub__1 x = casadi__Sparsity__sub__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sub__2" c_casadi__Sparsity__sub__2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__sub__2
  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
casadi__Sparsity__sub__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sub__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sub__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
sparsity_sub__2 x = casadi__Sparsity__sub__2 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sub__3" c_casadi__Sparsity__sub__3
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__sub__3
  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
casadi__Sparsity__sub__3 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sub__3 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_sub__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
sparsity_sub__3 x = casadi__Sparsity__sub__3 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__transpose__0" c_casadi__Sparsity__transpose__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__transpose__0
  :: Sparsity -> Vector Int -> IO Sparsity
casadi__Sparsity__transpose__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__transpose__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_transpose__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity
sparsity_transpose__0 x = casadi__Sparsity__transpose__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__transpose__1" c_casadi__Sparsity__transpose__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__transpose__1
  :: Sparsity -> Vector Int -> Bool -> IO Sparsity
casadi__Sparsity__transpose__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__transpose__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_transpose__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity
sparsity_transpose__1 x = casadi__Sparsity__transpose__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__triplet__0" c_casadi__Sparsity__triplet__0
  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__triplet__0
  :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
casadi__Sparsity__triplet__0 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__triplet__0 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_triplet__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity
sparsity_triplet__0 = casadi__Sparsity__triplet__0


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__triplet__1" c_casadi__Sparsity__triplet__1
  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__triplet__1
  :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
casadi__Sparsity__triplet__1 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__triplet__1 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_triplet__1 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
sparsity_triplet__1 = casadi__Sparsity__triplet__1


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__triplet__2" c_casadi__Sparsity__triplet__2
  :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__triplet__2
  :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
casadi__Sparsity__triplet__2 x0 x1 x2 x3 x4 x5 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  withMarshal x5 $ \x5' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__triplet__2 errStrPtrP x0' x1' x2' x3' x4' x5'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_triplet__2 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity
sparsity_triplet__2 = casadi__Sparsity__triplet__2


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__0" c_casadi__Sparsity__unidirectionalColoring__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__unidirectionalColoring__0
  :: Sparsity -> IO Sparsity
casadi__Sparsity__unidirectionalColoring__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__unidirectionalColoring__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_unidirectionalColoring__0 :: SparsityClass a => a -> IO Sparsity
sparsity_unidirectionalColoring__0 x = casadi__Sparsity__unidirectionalColoring__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__1" c_casadi__Sparsity__unidirectionalColoring__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__unidirectionalColoring__1
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__unidirectionalColoring__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__unidirectionalColoring__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_unidirectionalColoring__1 :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_unidirectionalColoring__1 x = casadi__Sparsity__unidirectionalColoring__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__2" c_casadi__Sparsity__unidirectionalColoring__2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__unidirectionalColoring__2
  :: Sparsity -> Sparsity -> Int -> IO Sparsity
casadi__Sparsity__unidirectionalColoring__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__unidirectionalColoring__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_unidirectionalColoring__2 :: SparsityClass a => a -> Sparsity -> Int -> IO Sparsity
sparsity_unidirectionalColoring__2 x = casadi__Sparsity__unidirectionalColoring__2 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__unit" c_casadi__Sparsity__unit
  :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__unit
  :: Int -> Int -> IO Sparsity
casadi__Sparsity__unit x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__unit errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_unit :: Int -> Int -> IO Sparsity
sparsity_unit = casadi__Sparsity__unit


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__upper" c_casadi__Sparsity__upper
  :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__upper
  :: Int -> IO Sparsity
casadi__Sparsity__upper x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__upper errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_upper :: Int -> IO Sparsity
sparsity_upper = casadi__Sparsity__upper


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_blockcat" c_casadi__Sparsity__zz_blockcat
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr Sparsity')
casadi__Sparsity__zz_blockcat
  :: Vector (Vector Sparsity) -> IO Sparsity
casadi__Sparsity__zz_blockcat x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_blockcat errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_blockcat :: Vector (Vector Sparsity) -> IO Sparsity
sparsity_zz_blockcat = casadi__Sparsity__zz_blockcat


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_blocksplit" c_casadi__Sparsity__zz_blocksplit
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))))
casadi__Sparsity__zz_blocksplit
  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector (Vector Sparsity))
casadi__Sparsity__zz_blocksplit x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_blocksplit errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_blocksplit :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector (Vector Sparsity))
sparsity_zz_blocksplit x = casadi__Sparsity__zz_blocksplit (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_diagcat" c_casadi__Sparsity__zz_diagcat
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
casadi__Sparsity__zz_diagcat
  :: Vector Sparsity -> IO Sparsity
casadi__Sparsity__zz_diagcat x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_diagcat errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_diagcat :: Vector Sparsity -> IO Sparsity
sparsity_zz_diagcat = casadi__Sparsity__zz_diagcat


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_diagsplit" c_casadi__Sparsity__zz_diagsplit
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
casadi__Sparsity__zz_diagsplit
  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Sparsity)
casadi__Sparsity__zz_diagsplit x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_diagsplit errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_diagsplit :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Sparsity)
sparsity_zz_diagsplit x = casadi__Sparsity__zz_diagsplit (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_horzcat" c_casadi__Sparsity__zz_horzcat
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
casadi__Sparsity__zz_horzcat
  :: Vector Sparsity -> IO Sparsity
casadi__Sparsity__zz_horzcat x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_horzcat errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_horzcat :: Vector Sparsity -> IO Sparsity
sparsity_zz_horzcat = casadi__Sparsity__zz_horzcat


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_horzsplit" c_casadi__Sparsity__zz_horzsplit
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
casadi__Sparsity__zz_horzsplit
  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
casadi__Sparsity__zz_horzsplit x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_horzsplit errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_horzsplit :: SparsityClass a => a -> Vector Int -> IO (Vector Sparsity)
sparsity_zz_horzsplit x = casadi__Sparsity__zz_horzsplit (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_kron" c_casadi__Sparsity__zz_kron
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__zz_kron
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__zz_kron x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_kron errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_kron :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_zz_kron x = casadi__Sparsity__zz_kron (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_mtimes__0" c_casadi__Sparsity__zz_mtimes__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__zz_mtimes__0
  :: Sparsity -> Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__zz_mtimes__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_mtimes__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_mtimes__0 :: SparsityClass a => a -> Sparsity -> Sparsity -> IO Sparsity
sparsity_zz_mtimes__0 x = casadi__Sparsity__zz_mtimes__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_mtimes__1" c_casadi__Sparsity__zz_mtimes__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__zz_mtimes__1
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__zz_mtimes__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_mtimes__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_mtimes__1 :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_zz_mtimes__1 x = casadi__Sparsity__zz_mtimes__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_norm_0_mul" c_casadi__Sparsity__zz_norm_0_mul
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__zz_norm_0_mul
  :: Sparsity -> Sparsity -> IO Int
casadi__Sparsity__zz_norm_0_mul x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_norm_0_mul errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_norm_0_mul :: SparsityClass a => a -> Sparsity -> IO Int
sparsity_zz_norm_0_mul x = casadi__Sparsity__zz_norm_0_mul (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_repmat__0" c_casadi__Sparsity__zz_repmat__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__zz_repmat__0
  :: Sparsity -> Int -> IO Sparsity
casadi__Sparsity__zz_repmat__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_repmat__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_repmat__0 :: SparsityClass a => a -> Int -> IO Sparsity
sparsity_zz_repmat__0 x = casadi__Sparsity__zz_repmat__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_repmat__1" c_casadi__Sparsity__zz_repmat__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__zz_repmat__1
  :: Sparsity -> Int -> Int -> IO Sparsity
casadi__Sparsity__zz_repmat__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_repmat__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_repmat__1 :: SparsityClass a => a -> Int -> Int -> IO Sparsity
sparsity_zz_repmat__1 x = casadi__Sparsity__zz_repmat__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_reshape__0" c_casadi__Sparsity__zz_reshape__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__zz_reshape__0
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__zz_reshape__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_reshape__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_reshape__0 :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_zz_reshape__0 x = casadi__Sparsity__zz_reshape__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_reshape__1" c_casadi__Sparsity__zz_reshape__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__zz_reshape__1
  :: Sparsity -> Int -> Int -> IO Sparsity
casadi__Sparsity__zz_reshape__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_reshape__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_reshape__1 :: SparsityClass a => a -> Int -> Int -> IO Sparsity
sparsity_zz_reshape__1 x = casadi__Sparsity__zz_reshape__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_sprank" c_casadi__Sparsity__zz_sprank
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__zz_sprank
  :: Sparsity -> IO Int
casadi__Sparsity__zz_sprank x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_sprank errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_sprank :: SparsityClass a => a -> IO Int
sparsity_zz_sprank x = casadi__Sparsity__zz_sprank (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_tril__0" c_casadi__Sparsity__zz_tril__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__zz_tril__0
  :: Sparsity -> IO Sparsity
casadi__Sparsity__zz_tril__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_tril__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_tril__0 :: SparsityClass a => a -> IO Sparsity
sparsity_zz_tril__0 x = casadi__Sparsity__zz_tril__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_tril__1" c_casadi__Sparsity__zz_tril__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__zz_tril__1
  :: Sparsity -> Bool -> IO Sparsity
casadi__Sparsity__zz_tril__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_tril__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_tril__1 :: SparsityClass a => a -> Bool -> IO Sparsity
sparsity_zz_tril__1 x = casadi__Sparsity__zz_tril__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_triu__0" c_casadi__Sparsity__zz_triu__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__zz_triu__0
  :: Sparsity -> IO Sparsity
casadi__Sparsity__zz_triu__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_triu__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_triu__0 :: SparsityClass a => a -> IO Sparsity
sparsity_zz_triu__0 x = casadi__Sparsity__zz_triu__0 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_triu__1" c_casadi__Sparsity__zz_triu__1
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__zz_triu__1
  :: Sparsity -> Bool -> IO Sparsity
casadi__Sparsity__zz_triu__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_triu__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_triu__1 :: SparsityClass a => a -> Bool -> IO Sparsity
sparsity_zz_triu__1 x = casadi__Sparsity__zz_triu__1 (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_vec" c_casadi__Sparsity__zz_vec
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__zz_vec
  :: Sparsity -> IO Sparsity
casadi__Sparsity__zz_vec x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_vec errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_vec :: SparsityClass a => a -> IO Sparsity
sparsity_zz_vec x = casadi__Sparsity__zz_vec (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_vecNZ" c_casadi__Sparsity__zz_vecNZ
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__zz_vecNZ
  :: Sparsity -> IO Sparsity
casadi__Sparsity__zz_vecNZ x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_vecNZ errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_vecNZ :: SparsityClass a => a -> IO Sparsity
sparsity_zz_vecNZ x = casadi__Sparsity__zz_vecNZ (castSparsity x)


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_vecNZcat" c_casadi__Sparsity__zz_vecNZcat
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
casadi__Sparsity__zz_vecNZcat
  :: Vector Sparsity -> IO Sparsity
casadi__Sparsity__zz_vecNZcat x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_vecNZcat errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_vecNZcat :: Vector Sparsity -> IO Sparsity
sparsity_zz_vecNZcat = casadi__Sparsity__zz_vecNZcat


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_veccat" c_casadi__Sparsity__zz_veccat
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
casadi__Sparsity__zz_veccat
  :: Vector Sparsity -> IO Sparsity
casadi__Sparsity__zz_veccat x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_veccat errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_veccat :: Vector Sparsity -> IO Sparsity
sparsity_zz_veccat = casadi__Sparsity__zz_veccat


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_vertcat" c_casadi__Sparsity__zz_vertcat
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
casadi__Sparsity__zz_vertcat
  :: Vector Sparsity -> IO Sparsity
casadi__Sparsity__zz_vertcat x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_vertcat errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_vertcat :: Vector Sparsity -> IO Sparsity
sparsity_zz_vertcat = casadi__Sparsity__zz_vertcat


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__zz_vertsplit" c_casadi__Sparsity__zz_vertsplit
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
casadi__Sparsity__zz_vertsplit
  :: Sparsity -> Vector Int -> IO (Vector Sparsity)
casadi__Sparsity__zz_vertsplit x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__zz_vertsplit errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_zz_vertsplit :: SparsityClass a => a -> Vector Int -> IO (Vector Sparsity)
sparsity_zz_vertsplit x = casadi__Sparsity__zz_vertsplit (castSparsity x)