casadi-bindings-1.8.0.0: Casadi/Wrappers/Classes/CRSSparsity.hs

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

module Casadi.Wrappers.Classes.CRSSparsity
       (
         CRSSparsity,
         CRSSparsityClass(..),
         crsSparsity,
         crsSparsity',
         crsSparsity_col,
         crsSparsity_colRef,
         crsSparsity_columnsSequential,
         crsSparsity_dimString,
         crsSparsity_empty,
         crsSparsity_getElements,
         crsSparsity_getNZ,
         crsSparsity_getNZ'',
         crsSparsity_getNZInplace,
         crsSparsity_getRow,
         crsSparsity_hasNZ,
         crsSparsity_hash,
         crsSparsity_null,
         crsSparsity_numel,
         crsSparsity_rowind,
         crsSparsity_rowindRef,
         crsSparsity_size,
         crsSparsity_size1,
         crsSparsity_size2,
         crsSparsity_sizeD,
         crsSparsity_sizeL,
         crsSparsity_sizeU,
         crsSparsity_spy',
         crsSparsity_spyMatlab,
         crsSparsity_starColoring,
         crsSparsity_starColoring',
         crsSparsity_starColoring'',
         crsSparsity_starColoring2,
         crsSparsity_starColoring2',
         crsSparsity_starColoring2'',
         crsSparsity_unidirectionalColoring,
         crsSparsity_unidirectionalColoring',
         crsSparsity_unidirectionalColoring'',
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Ptr ( Ptr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Wrappers.Classes.PrintableObject
import Casadi.Wrappers.ForeignToolsInstances ( )
import Casadi.Wrappers.Deleters
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,
                             StdString', CppBool' ) -- StdOstream'
import Casadi.Marshal ( CornerCase(..), Marshal(..) )
import Casadi.WrapReturn ( WrapReturn(..) )

instance Show CRSSparsity where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__size1" c_CasADi__CRSSparsity__size1
  :: Ptr CRSSparsity' -> IO CInt
casADi__CRSSparsity__size1
  :: CRSSparsity -> IO Int
casADi__CRSSparsity__size1 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__size1 x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of rows.
-}
crsSparsity_size1 :: CRSSparsityClass a => a -> IO Int
crsSparsity_size1 x = casADi__CRSSparsity__size1 (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__size2" c_CasADi__CRSSparsity__size2
  :: Ptr CRSSparsity' -> IO CInt
casADi__CRSSparsity__size2
  :: CRSSparsity -> IO Int
casADi__CRSSparsity__size2 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__size2 x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of columns.
-}
crsSparsity_size2 :: CRSSparsityClass a => a -> IO Int
crsSparsity_size2 x = casADi__CRSSparsity__size2 (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__numel" c_CasADi__CRSSparsity__numel
  :: Ptr CRSSparsity' -> IO CInt
casADi__CRSSparsity__numel
  :: CRSSparsity -> IO Int
casADi__CRSSparsity__numel x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__numel x0' >>= wrapReturn

-- classy wrapper
{-|
>The total number of elements, including structural zeros, i.e.
>size1()*size2()
>
>See:   size()
-}
crsSparsity_numel :: CRSSparsityClass a => a -> IO Int
crsSparsity_numel x = casADi__CRSSparsity__numel (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__empty" c_CasADi__CRSSparsity__empty
  :: Ptr CRSSparsity' -> IO (Ptr CppBool')
casADi__CRSSparsity__empty
  :: CRSSparsity -> IO Bool
casADi__CRSSparsity__empty x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__empty x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>Check if the sparsity is empty, i.e. one of its dimensions is 0.
-}
crsSparsity_empty :: CRSSparsityClass a => a -> IO Bool
crsSparsity_empty x = casADi__CRSSparsity__empty (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__null" c_CasADi__CRSSparsity__null
  :: Ptr CRSSparsity' -> IO (Ptr CppBool')
casADi__CRSSparsity__null
  :: CRSSparsity -> IO Bool
casADi__CRSSparsity__null x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__null x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>Check if the sparsity is null, i.e. dimension is 0-by-0.
-}
crsSparsity_null :: CRSSparsityClass a => a -> IO Bool
crsSparsity_null x = casADi__CRSSparsity__null (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__size" c_CasADi__CRSSparsity__size
  :: Ptr CRSSparsity' -> IO CInt
casADi__CRSSparsity__size
  :: CRSSparsity -> IO Int
casADi__CRSSparsity__size x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__size x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of (structural) non-zeros.
>
>See:   numel()
-}
crsSparsity_size :: CRSSparsityClass a => a -> IO Int
crsSparsity_size x = casADi__CRSSparsity__size (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__sizeU" c_CasADi__CRSSparsity__sizeU
  :: Ptr CRSSparsity' -> IO CInt
casADi__CRSSparsity__sizeU
  :: CRSSparsity -> IO Int
casADi__CRSSparsity__sizeU x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__sizeU x0' >>= wrapReturn

-- classy wrapper
{-|
>Number of non-zeros in the upper triangular half, i.e. the number of
>elements (i,j) with j>=i.
-}
crsSparsity_sizeU :: CRSSparsityClass a => a -> IO Int
crsSparsity_sizeU x = casADi__CRSSparsity__sizeU (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__sizeL" c_CasADi__CRSSparsity__sizeL
  :: Ptr CRSSparsity' -> IO CInt
casADi__CRSSparsity__sizeL
  :: CRSSparsity -> IO Int
casADi__CRSSparsity__sizeL x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__sizeL x0' >>= wrapReturn

-- classy wrapper
{-|
>Number of non-zeros in the lower triangular half, i.e. the number of
>elements (i,j) with j<=i.
-}
crsSparsity_sizeL :: CRSSparsityClass a => a -> IO Int
crsSparsity_sizeL x = casADi__CRSSparsity__sizeL (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__sizeD" c_CasADi__CRSSparsity__sizeD
  :: Ptr CRSSparsity' -> IO CInt
casADi__CRSSparsity__sizeD
  :: CRSSparsity -> IO Int
casADi__CRSSparsity__sizeD x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__sizeD x0' >>= wrapReturn

-- classy wrapper
{-|
>Number of non-zeros on the diagonal, i.e. the number of elements (i,j) with
>j==i.
-}
crsSparsity_sizeD :: CRSSparsityClass a => a -> IO Int
crsSparsity_sizeD x = casADi__CRSSparsity__sizeD (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__col" c_CasADi__CRSSparsity__col
  :: Ptr CRSSparsity' -> CInt -> IO CInt
casADi__CRSSparsity__col
  :: CRSSparsity -> Int -> IO Int
casADi__CRSSparsity__col x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__col x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  const vector< int > & CasADi::CRSSparsity::col() const 
>------------------------------------------------------------------------
>
>Get a reference to col-vector, containing columns for all non-zero elements
>(see class description)
>
>>  int CasADi::CRSSparsity::col(int el) const 
>------------------------------------------------------------------------
>
>Get the column of a non-zero element.
-}
crsSparsity_col :: CRSSparsityClass a => a -> Int -> IO Int
crsSparsity_col x = casADi__CRSSparsity__col (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__rowind" c_CasADi__CRSSparsity__rowind
  :: Ptr CRSSparsity' -> CInt -> IO CInt
casADi__CRSSparsity__rowind
  :: CRSSparsity -> Int -> IO Int
casADi__CRSSparsity__rowind x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__rowind x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  const vector< int > & CasADi::CRSSparsity::rowind() const 
>------------------------------------------------------------------------
>
>Get a reference to the rowindex of all row element (see class description)
>
>>  int CasADi::CRSSparsity::rowind(int i) const 
>------------------------------------------------------------------------
>
>Get a reference to the rowindex of row i (see class description)
-}
crsSparsity_rowind :: CRSSparsityClass a => a -> Int -> IO Int
crsSparsity_rowind x = casADi__CRSSparsity__rowind (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__colRef" c_CasADi__CRSSparsity__colRef
  :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))
casADi__CRSSparsity__colRef
  :: CRSSparsity -> IO (Vector Int)
casADi__CRSSparsity__colRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__colRef x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn

-- classy wrapper
{-|
>Get a reference to the columns of all non-zero element (copy if not unique!)
-}
crsSparsity_colRef :: CRSSparsityClass a => a -> IO (Vector Int)
crsSparsity_colRef x = casADi__CRSSparsity__colRef (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__rowindRef" c_CasADi__CRSSparsity__rowindRef
  :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))
casADi__CRSSparsity__rowindRef
  :: CRSSparsity -> IO (Vector Int)
casADi__CRSSparsity__rowindRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__rowindRef x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn

-- classy wrapper
{-|
>Get a reference to the rowindex of all row element (copy if not unique!)
-}
crsSparsity_rowindRef :: CRSSparsityClass a => a -> IO (Vector Int)
crsSparsity_rowindRef x = casADi__CRSSparsity__rowindRef (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__getRow" c_CasADi__CRSSparsity__getRow
  :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))
casADi__CRSSparsity__getRow
  :: CRSSparsity -> IO (Vector Int)
casADi__CRSSparsity__getRow x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__getRow x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn

-- classy wrapper
{-|
>Get the row for each non-zero entry Together with the col-vector, this
>vector gives the sparsity of the matrix in sparse triplet format, i.e. the
>row and column for each non-zero elements.
-}
crsSparsity_getRow :: CRSSparsityClass a => a -> IO (Vector Int)
crsSparsity_getRow x = casADi__CRSSparsity__getRow (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__getNZ" c_CasADi__CRSSparsity__getNZ
  :: Ptr CRSSparsity' -> CInt -> CInt -> IO CInt
casADi__CRSSparsity__getNZ
  :: CRSSparsity -> Int -> Int -> IO Int
casADi__CRSSparsity__getNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__CRSSparsity__getNZ x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  int CasADi::CRSSparsity::getNZ(int i, int j)
>------------------------------------------------------------------------
>
>Get the index of a non-zero element Add the element if it does not exist and
>copy object if it's not unique.
>
>>  int CasADi::CRSSparsity::getNZ(int i, int j) const 
>------------------------------------------------------------------------
>
>Get the index of an existing non-zero element return -1 if the element does
>not exists.
>
>>  std::vector<int> CasADi::CRSSparsity::getNZ(const std::vector< int > &ii, const std::vector< int > &jj) const 
>------------------------------------------------------------------------
>
>Get a set of non-zero element return -1 if the element does not exists.
-}
crsSparsity_getNZ :: CRSSparsityClass a => a -> Int -> Int -> IO Int
crsSparsity_getNZ x = casADi__CRSSparsity__getNZ (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__getNZ_TIC_TIC" c_CasADi__CRSSparsity__getNZ_TIC_TIC
  :: Ptr CRSSparsity' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr (CppVec CInt))
casADi__CRSSparsity__getNZ''
  :: CRSSparsity -> Vector Int -> Vector Int -> IO (Vector Int)
casADi__CRSSparsity__getNZ'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__CRSSparsity__getNZ_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn

-- classy wrapper
crsSparsity_getNZ'' :: CRSSparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)
crsSparsity_getNZ'' x = casADi__CRSSparsity__getNZ'' (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__hasNZ" c_CasADi__CRSSparsity__hasNZ
  :: Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr CppBool')
casADi__CRSSparsity__hasNZ
  :: CRSSparsity -> Int -> Int -> IO Bool
casADi__CRSSparsity__hasNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__CRSSparsity__hasNZ x0' x1' x2' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>Returns true if the pattern has a non-zero at location i,j.
-}
crsSparsity_hasNZ :: CRSSparsityClass a => a -> Int -> Int -> IO Bool
crsSparsity_hasNZ x = casADi__CRSSparsity__hasNZ (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__getNZInplace" c_CasADi__CRSSparsity__getNZInplace
  :: Ptr CRSSparsity' -> Ptr (CppVec CInt) -> IO ()
casADi__CRSSparsity__getNZInplace
  :: CRSSparsity -> Vector Int -> IO ()
casADi__CRSSparsity__getNZInplace x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__getNZInplace x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Get the nonzero index for a set of elements The index vector is used both
>for input and outputs and must be sorted by increasing nonzero index, i.e.
>row-wise. Elements not found in the sparsity pattern are set to -1.
-}
crsSparsity_getNZInplace :: CRSSparsityClass a => a -> Vector Int -> IO ()
crsSparsity_getNZInplace x = casADi__CRSSparsity__getNZInplace (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__columnsSequential" c_CasADi__CRSSparsity__columnsSequential
  :: Ptr CRSSparsity' -> Ptr CppBool' -> IO (Ptr CppBool')
casADi__CRSSparsity__columnsSequential
  :: CRSSparsity -> Bool -> IO Bool
casADi__CRSSparsity__columnsSequential x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__columnsSequential x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn

-- classy wrapper
{-|
>Does the columns appear sequentially on each row (if strictly==true, then do
>not allow multiple entries)
-}
crsSparsity_columnsSequential :: CRSSparsityClass a => a -> Bool -> IO Bool
crsSparsity_columnsSequential x = casADi__CRSSparsity__columnsSequential (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__getElements" c_CasADi__CRSSparsity__getElements
  :: Ptr CRSSparsity' -> Ptr CppBool' -> IO (Ptr (CppVec CInt))
casADi__CRSSparsity__getElements
  :: CRSSparsity -> Bool -> IO (Vector Int)
casADi__CRSSparsity__getElements x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__getElements x0' x1' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn

-- classy wrapper
{-|
>>  std::vector< int > CasADi::CRSSparsity::getElements(bool row_major=true) const 
>------------------------------------------------------------------------
>
>Get the location of all nonzero elements.
>
>>  void CasADi::CRSSparsity::getElements(std::vector< int > &loc, bool row_major=true) const 
>------------------------------------------------------------------------
>
>Get the location of all nonzero elements (inplace version)
-}
crsSparsity_getElements :: CRSSparsityClass a => a -> Bool -> IO (Vector Int)
crsSparsity_getElements x = casADi__CRSSparsity__getElements (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__unidirectionalColoring" c_CasADi__CRSSparsity__unidirectionalColoring
  :: Ptr CRSSparsity' -> Ptr CRSSparsity' -> CInt -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__unidirectionalColoring
  :: CRSSparsity -> CRSSparsity -> Int -> IO CRSSparsity
casADi__CRSSparsity__unidirectionalColoring x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__CRSSparsity__unidirectionalColoring x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
{-|
>Perform a unidirectional coloring: A greedy distance-2 coloring algorithm
>(Algorithm 3.1 in A. H. GEBREMEDHIN, F. MANNE, A. POTHEN)
-}
crsSparsity_unidirectionalColoring :: CRSSparsityClass a => a -> CRSSparsity -> Int -> IO CRSSparsity
crsSparsity_unidirectionalColoring x = casADi__CRSSparsity__unidirectionalColoring (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__unidirectionalColoring_TIC" c_CasADi__CRSSparsity__unidirectionalColoring_TIC
  :: Ptr CRSSparsity' -> Ptr CRSSparsity' -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__unidirectionalColoring'
  :: CRSSparsity -> CRSSparsity -> IO CRSSparsity
casADi__CRSSparsity__unidirectionalColoring' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__unidirectionalColoring_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
crsSparsity_unidirectionalColoring' :: CRSSparsityClass a => a -> CRSSparsity -> IO CRSSparsity
crsSparsity_unidirectionalColoring' x = casADi__CRSSparsity__unidirectionalColoring' (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC" c_CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC
  :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__unidirectionalColoring''
  :: CRSSparsity -> IO CRSSparsity
casADi__CRSSparsity__unidirectionalColoring'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
crsSparsity_unidirectionalColoring'' :: CRSSparsityClass a => a -> IO CRSSparsity
crsSparsity_unidirectionalColoring'' x = casADi__CRSSparsity__unidirectionalColoring'' (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__starColoring" c_CasADi__CRSSparsity__starColoring
  :: Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__starColoring
  :: CRSSparsity -> Int -> Int -> IO CRSSparsity
casADi__CRSSparsity__starColoring x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__CRSSparsity__starColoring x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
{-|
>Perform a star coloring of a symmetric matrix: A greedy distance-2 coloring
>algorithm (Algorithm 4.1 in A. H. GEBREMEDHIN, F. MANNE, A. POTHEN) Ordering
>options: None (0), largest first (1)
-}
crsSparsity_starColoring :: CRSSparsityClass a => a -> Int -> Int -> IO CRSSparsity
crsSparsity_starColoring x = casADi__CRSSparsity__starColoring (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__starColoring_TIC" c_CasADi__CRSSparsity__starColoring_TIC
  :: Ptr CRSSparsity' -> CInt -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__starColoring'
  :: CRSSparsity -> Int -> IO CRSSparsity
casADi__CRSSparsity__starColoring' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__starColoring_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
crsSparsity_starColoring' :: CRSSparsityClass a => a -> Int -> IO CRSSparsity
crsSparsity_starColoring' x = casADi__CRSSparsity__starColoring' (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__starColoring_TIC_TIC" c_CasADi__CRSSparsity__starColoring_TIC_TIC
  :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__starColoring''
  :: CRSSparsity -> IO CRSSparsity
casADi__CRSSparsity__starColoring'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__starColoring_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
crsSparsity_starColoring'' :: CRSSparsityClass a => a -> IO CRSSparsity
crsSparsity_starColoring'' x = casADi__CRSSparsity__starColoring'' (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__starColoring2" c_CasADi__CRSSparsity__starColoring2
  :: Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__starColoring2
  :: CRSSparsity -> Int -> Int -> IO CRSSparsity
casADi__CRSSparsity__starColoring2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__CRSSparsity__starColoring2 x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
{-|
>Perform a star coloring of a symmetric matrix: A new greedy distance-2
>coloring algorithm (Algorithm 4.1 in A. H. GEBREMEDHIN, A. TARAFDAR, F.
>MANNE, A. POTHEN) Ordering options: None (0), largest first (1)
-}
crsSparsity_starColoring2 :: CRSSparsityClass a => a -> Int -> Int -> IO CRSSparsity
crsSparsity_starColoring2 x = casADi__CRSSparsity__starColoring2 (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__starColoring2_TIC" c_CasADi__CRSSparsity__starColoring2_TIC
  :: Ptr CRSSparsity' -> CInt -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__starColoring2'
  :: CRSSparsity -> Int -> IO CRSSparsity
casADi__CRSSparsity__starColoring2' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__starColoring2_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
crsSparsity_starColoring2' :: CRSSparsityClass a => a -> Int -> IO CRSSparsity
crsSparsity_starColoring2' x = casADi__CRSSparsity__starColoring2' (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__starColoring2_TIC_TIC" c_CasADi__CRSSparsity__starColoring2_TIC_TIC
  :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__starColoring2''
  :: CRSSparsity -> IO CRSSparsity
casADi__CRSSparsity__starColoring2'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__starColoring2_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
crsSparsity_starColoring2'' :: CRSSparsityClass a => a -> IO CRSSparsity
crsSparsity_starColoring2'' x = casADi__CRSSparsity__starColoring2'' (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__dimString" c_CasADi__CRSSparsity__dimString
  :: Ptr CRSSparsity' -> IO (Ptr StdString')
casADi__CRSSparsity__dimString
  :: CRSSparsity -> IO String
casADi__CRSSparsity__dimString x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__dimString x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn

-- classy wrapper
{-|
>Get the dimension as a string.
-}
crsSparsity_dimString :: CRSSparsityClass a => a -> IO String
crsSparsity_dimString x = casADi__CRSSparsity__dimString (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__spy_TIC" c_CasADi__CRSSparsity__spy_TIC
  :: Ptr CRSSparsity' -> IO ()
casADi__CRSSparsity__spy'
  :: CRSSparsity -> IO ()
casADi__CRSSparsity__spy' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__spy_TIC x0' >>= wrapReturn

-- classy wrapper
crsSparsity_spy' :: CRSSparsityClass a => a -> IO ()
crsSparsity_spy' x = casADi__CRSSparsity__spy' (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__spyMatlab" c_CasADi__CRSSparsity__spyMatlab
  :: Ptr CRSSparsity' -> Ptr StdString' -> IO ()
casADi__CRSSparsity__spyMatlab
  :: CRSSparsity -> String -> IO ()
casADi__CRSSparsity__spyMatlab x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__CRSSparsity__spyMatlab x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Generate a script for Matlab or Octave which visualizes the sparsity using
>the spy command.
-}
crsSparsity_spyMatlab :: CRSSparsityClass a => a -> String -> IO ()
crsSparsity_spyMatlab x = casADi__CRSSparsity__spyMatlab (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__hash" c_CasADi__CRSSparsity__hash
  :: Ptr CRSSparsity' -> IO CSize
casADi__CRSSparsity__hash
  :: CRSSparsity -> IO CSize
casADi__CRSSparsity__hash x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__CRSSparsity__hash x0' >>= wrapReturn

-- classy wrapper
crsSparsity_hash :: CRSSparsityClass a => a -> IO CSize
crsSparsity_hash x = casADi__CRSSparsity__hash (castCRSSparsity x)


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__CRSSparsity" c_CasADi__CRSSparsity__CRSSparsity
  :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr CRSSparsity')
casADi__CRSSparsity__CRSSparsity
  :: Int -> Int -> Vector Int -> Vector Int -> IO CRSSparsity
casADi__CRSSparsity__CRSSparsity x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__CRSSparsity__CRSSparsity x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::CRSSparsity::CRSSparsity(int dummy=0)
>------------------------------------------------------------------------
>
>Default constructor.
>
>>  CasADi::CRSSparsity::CRSSparsity(int nrow, int ncol, bool dense=false)
>------------------------------------------------------------------------
>
>Construct a sparsity pattern (sparse/dense)
>
>>  CasADi::CRSSparsity::CRSSparsity(int nrow, int ncol, const std::vector< int > &col, const std::vector< int > &rowind)
>------------------------------------------------------------------------
>
>Construct a sparsity pattern from vectors.
-}
crsSparsity :: Int -> Int -> Vector Int -> Vector Int -> IO CRSSparsity
crsSparsity = casADi__CRSSparsity__CRSSparsity


-- direct wrapper
foreign import ccall unsafe "CasADi__CRSSparsity__CRSSparsity_TIC" c_CasADi__CRSSparsity__CRSSparsity_TIC
  :: IO (Ptr CRSSparsity')
casADi__CRSSparsity__CRSSparsity'
  :: IO CRSSparsity
casADi__CRSSparsity__CRSSparsity'  =
  c_CasADi__CRSSparsity__CRSSparsity_TIC  >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
crsSparsity' :: IO CRSSparsity
crsSparsity' = casADi__CRSSparsity__CRSSparsity'