casadi-bindings-core-2.4.1.0: Casadi/Core/Classes/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_dense__2,
         sparsity_depthFirstSearch,
         sparsity_diag__0,
         sparsity_diag__1,
         sparsity_diag__2,
         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_isEqual__0,
         sparsity_isEqual__1,
         sparsity_isReshape,
         sparsity_isTranspose,
         sparsity_iscolumn,
         sparsity_isdense,
         sparsity_isdiag,
         sparsity_isempty__0,
         sparsity_isempty__1,
         sparsity_isrow,
         sparsity_isscalar__0,
         sparsity_isscalar__1,
         sparsity_issingular,
         sparsity_issquare,
         sparsity_issymmetric,
         sparsity_istril,
         sparsity_istriu,
         sparsity_isvector,
         sparsity_largestFirstOrdering,
         sparsity_lower,
         sparsity_makeDense,
         sparsity_nnz,
         sparsity_numel,
         sparsity_operator_equals,
         sparsity_operator_mul,
         sparsity_operator_nequals,
         sparsity_operator_plus,
         sparsity_patternCombine,
         sparsity_patternIntersection,
         sparsity_patternInverse,
         sparsity_patternProduct,
         sparsity_patternUnion,
         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_shape,
         sparsity_size1,
         sparsity_size2,
         sparsity_sizeD,
         sparsity_sizeL,
         sparsity_sizeU,
         sparsity_sparse__0,
         sparsity_sparse__1,
         sparsity_sparse__2,
         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_tril__0,
         sparsity_zz_tril__1,
         sparsity_zz_triu__0,
         sparsity_zz_triu__1,
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import qualified Data.Map as M
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.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- 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) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__dense__0
  :: (Int, 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, 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 -> IO (Ptr Sparsity')
casadi__Sparsity__dense__1
  :: Int -> IO Sparsity
casadi__Sparsity__dense__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__dense__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


-- classy wrapper
sparsity_dense__2 :: Int -> Int -> IO Sparsity
sparsity_dense__2 = casadi__Sparsity__dense__2


-- 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) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__diag__0
  :: (Int, Int) -> IO Sparsity
casadi__Sparsity__diag__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__diag__0 errStrPtrP x0'
    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 -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__diag__1
  :: Int -> Int -> IO Sparsity
casadi__Sparsity__diag__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__diag__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


-- classy wrapper
sparsity_diag__2 :: Int -> IO Sparsity
sparsity_diag__2 = casadi__Sparsity__diag__2


-- 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__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__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__iscolumn" c_casadi__Sparsity__iscolumn
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__iscolumn
  :: Sparsity -> IO Bool
casadi__Sparsity__iscolumn x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__iscolumn errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_iscolumn :: SparsityClass a => a -> IO Bool
sparsity_iscolumn x = casadi__Sparsity__iscolumn (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__isdiag" c_casadi__Sparsity__isdiag
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isdiag
  :: Sparsity -> IO Bool
casadi__Sparsity__isdiag x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isdiag errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isdiag :: SparsityClass a => a -> IO Bool
sparsity_isdiag x = casadi__Sparsity__isdiag (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__isrow" c_casadi__Sparsity__isrow
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isrow
  :: Sparsity -> IO Bool
casadi__Sparsity__isrow x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isrow errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isrow :: SparsityClass a => a -> IO Bool
sparsity_isrow x = casadi__Sparsity__isrow (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__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" c_casadi__Sparsity__isvector
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
casadi__Sparsity__isvector
  :: Sparsity -> IO Bool
casadi__Sparsity__isvector x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__isvector errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_isvector :: SparsityClass a => a -> IO Bool
sparsity_isvector x = casadi__Sparsity__isvector (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" c_casadi__Sparsity__patternCombine
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__patternCombine
  :: Sparsity -> Sparsity -> Bool -> Bool -> IO Sparsity
casadi__Sparsity__patternCombine 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 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 :: SparsityClass a => a -> Sparsity -> Bool -> Bool -> IO Sparsity
sparsity_patternCombine x = casadi__Sparsity__patternCombine (castSparsity x)


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


-- classy wrapper
sparsity_patternIntersection :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_patternIntersection x = casadi__Sparsity__patternIntersection (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" c_casadi__Sparsity__patternUnion
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__patternUnion
  :: Sparsity -> Sparsity -> IO Sparsity
casadi__Sparsity__patternUnion x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__patternUnion errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_patternUnion :: SparsityClass a => a -> Sparsity -> IO Sparsity
sparsity_patternUnion x = casadi__Sparsity__patternUnion (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__shape" c_casadi__Sparsity__shape
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdPair CInt CInt))
casadi__Sparsity__shape
  :: Sparsity -> IO (Int, Int)
casadi__Sparsity__shape x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__shape errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_shape :: SparsityClass a => a -> IO (Int, Int)
sparsity_shape x = casadi__Sparsity__shape (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) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__sparse__0
  :: (Int, 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, 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 -> IO (Ptr Sparsity')
casadi__Sparsity__sparse__1
  :: Int -> IO Sparsity
casadi__Sparsity__sparse__1 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__sparse__1 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


-- classy wrapper
sparsity_sparse__2 :: Int -> Int -> IO Sparsity
sparsity_sparse__2 = casadi__Sparsity__sparse__2


-- 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_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)