{-# 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__0,
         sparsity__1,
         sparsity__2,
         sparsity_append,
         sparsity_appendColumns,
         sparsity_band,
         sparsity_banded,
         sparsity_clearCache,
         sparsity_colind__0,
         sparsity_colind__1,
         sparsity_compress,
         sparsity_compressed,
         sparsity_dense__0,
         sparsity_dense__1,
         sparsity_depthFirstSearch,
         sparsity_diag__0,
         sparsity_diag__1,
         sparsity_dimString,
         sparsity_dulmageMendelsohn__0,
         sparsity_dulmageMendelsohn__1,
         sparsity_eliminationTree__0,
         sparsity_eliminationTree__1,
         sparsity_enlarge,
         sparsity_enlargeColumns,
         sparsity_enlargeRows,
         sparsity_erase,
         sparsity_getCCS,
         sparsity_getCRS,
         sparsity_getCol,
         sparsity_getDiag,
         sparsity_getElements__0,
         sparsity_getElements__1,
         sparsity_getElements__2,
         sparsity_getElements__3,
         sparsity_getLowerNZ,
         sparsity_getNZInplace,
         sparsity_getNZ__0,
         sparsity_getNZ__1,
         sparsity_getNZ__2,
         sparsity_getTril__0,
         sparsity_getTril__1,
         sparsity_getTriplet,
         sparsity_getTriu__0,
         sparsity_getTriu__1,
         sparsity_getUpperNZ,
         sparsity_hasNZ,
         sparsity_hash,
         sparsity_isDense,
         sparsity_isDiagonal,
         sparsity_isEmpty__0,
         sparsity_isEmpty__1,
         sparsity_isEqual__0,
         sparsity_isEqual__1,
         sparsity_isReshape,
         sparsity_isScalar__0,
         sparsity_isScalar__1,
         sparsity_isSingular,
         sparsity_isSquare,
         sparsity_isSymmetric,
         sparsity_isTranspose,
         sparsity_isTril,
         sparsity_isTriu,
         sparsity_isVector,
         sparsity_largestFirstOrdering,
         sparsity_makeDense,
         sparsity_numel,
         sparsity_patternCombine__0,
         sparsity_patternCombine__1,
         sparsity_patternIntersection__0,
         sparsity_patternIntersection__1,
         sparsity_patternInverse,
         sparsity_patternProduct,
         sparsity_patternUnion__0,
         sparsity_patternUnion__1,
         sparsity_pmult__0,
         sparsity_pmult__1,
         sparsity_pmult__2,
         sparsity_pmult__3,
         sparsity_printCompact,
         sparsity_reCache,
         sparsity_removeDuplicates,
         sparsity_reserve,
         sparsity_reshape,
         sparsity_resize,
         sparsity_row__0,
         sparsity_row__1,
         sparsity_rowcol,
         sparsity_rowsSequential__0,
         sparsity_rowsSequential__1,
         sparsity_sanityCheck__0,
         sparsity_sanityCheck__1,
         sparsity_scalar__0,
         sparsity_scalar__1,
         sparsity_size,
         sparsity_size1,
         sparsity_size2,
         sparsity_sizeD,
         sparsity_sizeL,
         sparsity_sizeU,
         sparsity_sparse__0,
         sparsity_sparse__1,
         sparsity_spy,
         sparsity_spyMatlab,
         sparsity_starColoring2__0,
         sparsity_starColoring2__1,
         sparsity_starColoring2__2,
         sparsity_starColoring__0,
         sparsity_starColoring__1,
         sparsity_starColoring__2,
         sparsity_stronglyConnectedComponents,
         sparsity_sub,
         sparsity_transpose__0,
         sparsity_transpose__1,
         sparsity_transpose__2,
         sparsity_tril,
         sparsity_triplet__0,
         sparsity_triplet__1,
         sparsity_triplet__2,
         sparsity_triu,
         sparsity_unidirectionalColoring__0,
         sparsity_unidirectionalColoring__1,
         sparsity_unidirectionalColoring__2,
         sparsity_unit,
       ) where


import Prelude hiding ( Functor )

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

import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
import Casadi.Internal.WrapReturn ( WrapReturn(..) )
import Casadi.Core.Data
import Casadi.Core.Enums

instance Show Sparsity where
  show = unsafePerformIO . printableObject_getDescription
-- 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) -> IO (Ptr Sparsity')
casadi__Sparsity__CONSTRUCTOR__1
  :: IO Sparsity
casadi__Sparsity__CONSTRUCTOR__1  =

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


-- classy wrapper
sparsity__1 :: 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) -> CInt -> IO (Ptr Sparsity')
casadi__Sparsity__CONSTRUCTOR__2
  :: Int -> IO Sparsity
casadi__Sparsity__CONSTRUCTOR__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__CONSTRUCTOR__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


-- classy wrapper
sparsity_colind__0 :: SparsityClass a => a -> Int -> IO Int
sparsity_colind__0 x = casadi__Sparsity__colind__0 (castSparsity x)


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


-- classy wrapper
sparsity_colind__1 :: SparsityClass a => a -> IO (Vector Int)
sparsity_colind__1 x = casadi__Sparsity__colind__1 (castSparsity x)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__enlarge" c_casadi__Sparsity__enlarge
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__enlarge
  :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casadi__Sparsity__enlarge 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 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 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
sparsity_enlarge x = casadi__Sparsity__enlarge (castSparsity x)


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


-- classy wrapper
sparsity_enlargeColumns :: SparsityClass a => a -> Int -> Vector Int -> IO ()
sparsity_enlargeColumns x = casadi__Sparsity__enlargeColumns (castSparsity x)


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


-- classy wrapper
sparsity_enlargeRows :: SparsityClass a => a -> Int -> Vector Int -> IO ()
sparsity_enlargeRows x = casadi__Sparsity__enlargeRows (castSparsity x)


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


-- classy wrapper
sparsity_erase :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)
sparsity_erase x = casadi__Sparsity__erase (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__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__getElements__0" c_casadi__Sparsity__getElements__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__getElements__0
  :: Sparsity -> Vector Int -> IO ()
casadi__Sparsity__getElements__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getElements__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getElements__0 :: SparsityClass a => a -> Vector Int -> IO ()
sparsity_getElements__0 x = casadi__Sparsity__getElements__0 (castSparsity x)


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


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


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


-- classy wrapper
sparsity_getElements__2 :: SparsityClass a => a -> IO (Vector Int)
sparsity_getElements__2 x = casadi__Sparsity__getElements__2 (castSparsity x)


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


-- classy wrapper
sparsity_getElements__3 :: SparsityClass a => a -> Bool -> IO (Vector Int)
sparsity_getElements__3 x = casadi__Sparsity__getElements__3 (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) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt))
casadi__Sparsity__getNZ__0
  :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int)
casadi__Sparsity__getNZ__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getNZ__0 errStrPtrP x0' x1' x2'
    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 -> Vector Int -> IO (Vector Int)
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' -> CInt -> CInt -> IO CInt
casadi__Sparsity__getNZ__1
  :: Sparsity -> Int -> Int -> IO 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 -> Int -> Int -> IO 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__getNZInplace" c_casadi__Sparsity__getNZInplace
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO ()
casadi__Sparsity__getNZInplace
  :: Sparsity -> Vector Int -> IO ()
casadi__Sparsity__getNZInplace x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getNZInplace errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getNZInplace :: SparsityClass a => a -> Vector Int -> IO ()
sparsity_getNZInplace x = casadi__Sparsity__getNZInplace (castSparsity x)


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


-- classy wrapper
sparsity_getTril__0 :: SparsityClass a => a -> IO Sparsity
sparsity_getTril__0 x = casadi__Sparsity__getTril__0 (castSparsity x)


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


-- classy wrapper
sparsity_getTril__1 :: SparsityClass a => a -> Bool -> IO Sparsity
sparsity_getTril__1 x = casadi__Sparsity__getTril__1 (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__getTriu__0" c_casadi__Sparsity__getTriu__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__getTriu__0
  :: Sparsity -> IO Sparsity
casadi__Sparsity__getTriu__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__getTriu__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_getTriu__0 :: SparsityClass a => a -> IO Sparsity
sparsity_getTriu__0 x = casadi__Sparsity__getTriu__0 (castSparsity x)


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


-- classy wrapper
sparsity_getTriu__1 :: SparsityClass a => a -> Bool -> IO Sparsity
sparsity_getTriu__1 x = casadi__Sparsity__getTriu__1 (castSparsity x)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


-- classy wrapper
sparsity_reshape :: SparsityClass a => a -> Int -> Int -> IO Sparsity
sparsity_reshape x = casadi__Sparsity__reshape (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__0" c_casadi__Sparsity__row__0
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt
casadi__Sparsity__row__0
  :: Sparsity -> Int -> IO Int
casadi__Sparsity__row__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__row__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_row__0 :: SparsityClass a => a -> Int -> IO Int
sparsity_row__0 x = casadi__Sparsity__row__0 (castSparsity x)


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


-- classy wrapper
sparsity_row__1 :: SparsityClass a => a -> IO (Vector Int)
sparsity_row__1 x = casadi__Sparsity__row__1 (castSparsity x)


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


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


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


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


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


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


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


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


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


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


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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


-- direct wrapper
foreign import ccall unsafe "casadi__Sparsity__sub" c_casadi__Sparsity__sub
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity')
casadi__Sparsity__sub
  :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
casadi__Sparsity__sub 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 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 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity
sparsity_sub x = casadi__Sparsity__sub (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__transpose__2" c_casadi__Sparsity__transpose__2
  :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
casadi__Sparsity__transpose__2
  :: Sparsity -> IO Sparsity
casadi__Sparsity__transpose__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__Sparsity__transpose__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sparsity_transpose__2 :: SparsityClass a => a -> IO Sparsity
sparsity_transpose__2 x = casadi__Sparsity__transpose__2 (castSparsity x)


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


-- classy wrapper
sparsity_tril :: Int -> IO Sparsity
sparsity_tril = casadi__Sparsity__tril


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


-- classy wrapper
sparsity_triu :: Int -> IO Sparsity
sparsity_triu = casadi__Sparsity__triu


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