diff --git a/Casadi/Core/Classes/DMatrix.hs b/Casadi/Core/Classes/DMatrix.hs --- a/Casadi/Core/Classes/DMatrix.hs +++ b/Casadi/Core/Classes/DMatrix.hs @@ -86,6 +86,7 @@ dmatrix_floor, dmatrix_fmax, dmatrix_fmin, + dmatrix_fmod, dmatrix_getElement__0, dmatrix_getElement__1, dmatrix_getEqualityCheckingDepth, @@ -1919,6 +1920,27 @@ -- classy wrapper dmatrix_fmin :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_fmin x = casadi__DMatrix__fmin (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__fmod" c_casadi__DMatrix__fmod + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__fmod + :: DMatrix -> DMatrix -> IO DMatrix +casadi__DMatrix__fmod x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__fmod errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_fmod :: DMatrixClass a => a -> DMatrix -> IO DMatrix +dmatrix_fmod x = casadi__DMatrix__fmod (castDMatrix x) -- direct wrapper diff --git a/Casadi/Core/Classes/IMatrix.hs b/Casadi/Core/Classes/IMatrix.hs --- a/Casadi/Core/Classes/IMatrix.hs +++ b/Casadi/Core/Classes/IMatrix.hs @@ -83,6 +83,7 @@ imatrix_floor, imatrix_fmax, imatrix_fmin, + imatrix_fmod, imatrix_getElement__0, imatrix_getElement__1, imatrix_getEqualityCheckingDepth, @@ -1854,6 +1855,27 @@ -- classy wrapper imatrix_fmin :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_fmin x = casadi__IMatrix__fmin (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__fmod" c_casadi__IMatrix__fmod + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__fmod + :: IMatrix -> IMatrix -> IO IMatrix +casadi__IMatrix__fmod x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__fmod errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_fmod :: IMatrixClass a => a -> IMatrix -> IO IMatrix +imatrix_fmod x = casadi__IMatrix__fmod (castIMatrix x) -- direct wrapper diff --git a/Casadi/Core/Classes/MX.hs b/Casadi/Core/Classes/MX.hs --- a/Casadi/Core/Classes/MX.hs +++ b/Casadi/Core/Classes/MX.hs @@ -79,6 +79,7 @@ mx_floor, mx_fmax, mx_fmin, + mx_fmod, mx_getDep__0, mx_getDep__1, mx_getEqualityCheckingDepth, @@ -1734,6 +1735,27 @@ -- classy wrapper mx_fmin :: MXClass a => a -> MX -> IO MX mx_fmin x = casadi__MX__fmin (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__fmod" c_casadi__MX__fmod + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi__MX__fmod + :: MX -> MX -> IO MX +casadi__MX__fmod x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__fmod errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_fmod :: MXClass a => a -> MX -> IO MX +mx_fmod x = casadi__MX__fmod (castMX x) -- direct wrapper diff --git a/Casadi/Core/Classes/SX.hs b/Casadi/Core/Classes/SX.hs --- a/Casadi/Core/Classes/SX.hs +++ b/Casadi/Core/Classes/SX.hs @@ -89,6 +89,7 @@ sx_floor, sx_fmax, sx_fmin, + sx_fmod, sx_getElement__0, sx_getElement__1, sx_getEqualityCheckingDepth, @@ -1984,6 +1985,27 @@ -- classy wrapper sx_fmin :: SXClass a => a -> SX -> IO SX sx_fmin x = casadi__SX__fmin (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__fmod" c_casadi__SX__fmod + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi__SX__fmod + :: SX -> SX -> IO SX +casadi__SX__fmod x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__fmod errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_fmod :: SXClass a => a -> SX -> IO SX +sx_fmod x = casadi__SX__fmod (castSX x) -- direct wrapper diff --git a/Casadi/Core/Classes/SXElement.hs b/Casadi/Core/Classes/SXElement.hs --- a/Casadi/Core/Classes/SXElement.hs +++ b/Casadi/Core/Classes/SXElement.hs @@ -68,6 +68,7 @@ sxElement_fmax__1, sxElement_fmin__0, sxElement_fmin__1, + sxElement_fmod, sxElement_getDep__0, sxElement_getDep__1, sxElement_getIntValue, @@ -1360,6 +1361,27 @@ -- classy wrapper sxElement_fmin__1 :: SXElementClass a => a -> SXElement -> IO SXElement sxElement_fmin__1 x = casadi__SXElement__fmin__1 (castSXElement x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXElement__fmod" c_casadi__SXElement__fmod + :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement') +casadi__SXElement__fmod + :: SXElement -> SXElement -> IO SXElement +casadi__SXElement__fmod x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXElement__fmod errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxElement_fmod :: SXElementClass a => a -> SXElement -> IO SXElement +sxElement_fmod x = casadi__SXElement__fmod (castSXElement x) -- direct wrapper diff --git a/Casadi/Core/Enums.hs b/Casadi/Core/Enums.hs --- a/Casadi/Core/Enums.hs +++ b/Casadi/Core/Enums.hs @@ -880,6 +880,7 @@ | OP_FLOOR | OP_FMAX | OP_FMIN + | OP_FMOD | OP_GETNONZEROS | OP_HORZCAT | OP_HORZSPLIT @@ -926,154 +927,156 @@ | OP_VERTSPLIT deriving (Show, Eq) instance Enum Operation where - fromEnum (NUM_BUILT_IN_OPS) = 73 + fromEnum (NUM_BUILT_IN_OPS) = 74 fromEnum (OP_ACOS) = 17 - fromEnum (OP_ACOSH) = 40 + fromEnum (OP_ACOSH) = 41 fromEnum (OP_ADD) = 1 - fromEnum (OP_ADDNONZEROS) = 62 + fromEnum (OP_ADDNONZEROS) = 63 fromEnum (OP_AND) = 24 fromEnum (OP_ASIN) = 16 - fromEnum (OP_ASINH) = 39 - fromEnum (OP_ASSERTION) = 65 + fromEnum (OP_ASINH) = 40 + fromEnum (OP_ASSERTION) = 66 fromEnum (OP_ASSIGN) = 0 fromEnum (OP_ATAN) = 18 - fromEnum (OP_ATAN2) = 42 - fromEnum (OP_ATANH) = 41 - fromEnum (OP_CALL) = 47 + fromEnum (OP_ATAN2) = 43 + fromEnum (OP_ATANH) = 42 + fromEnum (OP_CALL) = 48 fromEnum (OP_CEIL) = 27 - fromEnum (OP_CONST) = 43 + fromEnum (OP_CONST) = 44 fromEnum (OP_CONSTPOW) = 9 - fromEnum (OP_COPYSIGN) = 30 + fromEnum (OP_COPYSIGN) = 31 fromEnum (OP_COS) = 14 - fromEnum (OP_COSH) = 37 - fromEnum (OP_DETERMINANT) = 51 + fromEnum (OP_COSH) = 38 + fromEnum (OP_DETERMINANT) = 52 fromEnum (OP_DIV) = 4 fromEnum (OP_EQ) = 21 - fromEnum (OP_ERF) = 32 - fromEnum (OP_ERFINV) = 70 + fromEnum (OP_ERF) = 33 + fromEnum (OP_ERFINV) = 71 fromEnum (OP_EXP) = 6 - fromEnum (OP_FABS) = 28 + fromEnum (OP_FABS) = 29 fromEnum (OP_FLOOR) = 26 - fromEnum (OP_FMAX) = 34 - fromEnum (OP_FMIN) = 33 - fromEnum (OP_GETNONZEROS) = 61 - fromEnum (OP_HORZCAT) = 54 - fromEnum (OP_HORZSPLIT) = 56 - fromEnum (OP_IF_ELSE_ZERO) = 31 - fromEnum (OP_INNER_PROD) = 53 - fromEnum (OP_INPUT) = 44 - fromEnum (OP_INV) = 35 - fromEnum (OP_INVERSE) = 52 + fromEnum (OP_FMAX) = 35 + fromEnum (OP_FMIN) = 34 + fromEnum (OP_FMOD) = 28 + fromEnum (OP_GETNONZEROS) = 62 + fromEnum (OP_HORZCAT) = 55 + fromEnum (OP_HORZSPLIT) = 57 + fromEnum (OP_IF_ELSE_ZERO) = 32 + fromEnum (OP_INNER_PROD) = 54 + fromEnum (OP_INPUT) = 45 + fromEnum (OP_INV) = 36 + fromEnum (OP_INVERSE) = 53 fromEnum (OP_LE) = 20 - fromEnum (OP_LIFT) = 72 + fromEnum (OP_LIFT) = 73 fromEnum (OP_LOG) = 7 fromEnum (OP_LT) = 19 - fromEnum (OP_MATMUL) = 48 + fromEnum (OP_MATMUL) = 49 fromEnum (OP_MUL) = 3 fromEnum (OP_NE) = 22 fromEnum (OP_NEG) = 5 - fromEnum (OP_NORM1) = 67 - fromEnum (OP_NORM2) = 66 - fromEnum (OP_NORMF) = 69 - fromEnum (OP_NORMINF) = 68 + fromEnum (OP_NORM1) = 68 + fromEnum (OP_NORM2) = 67 + fromEnum (OP_NORMF) = 70 + fromEnum (OP_NORMINF) = 69 fromEnum (OP_NOT) = 23 fromEnum (OP_OR) = 25 - fromEnum (OP_OUTPUT) = 45 - fromEnum (OP_PARAMETER) = 46 + fromEnum (OP_OUTPUT) = 46 + fromEnum (OP_PARAMETER) = 47 fromEnum (OP_POW) = 8 - fromEnum (OP_PRINTME) = 71 - fromEnum (OP_RESHAPE) = 58 - fromEnum (OP_SETNONZEROS) = 63 - fromEnum (OP_SET_SPARSE) = 64 - fromEnum (OP_SIGN) = 29 + fromEnum (OP_PRINTME) = 72 + fromEnum (OP_RESHAPE) = 59 + fromEnum (OP_SETNONZEROS) = 64 + fromEnum (OP_SET_SPARSE) = 65 + fromEnum (OP_SIGN) = 30 fromEnum (OP_SIN) = 13 - fromEnum (OP_SINH) = 36 - fromEnum (OP_SOLVE) = 49 + fromEnum (OP_SINH) = 37 + fromEnum (OP_SOLVE) = 50 fromEnum (OP_SQ) = 11 fromEnum (OP_SQRT) = 10 fromEnum (OP_SUB) = 2 - fromEnum (OP_SUBASSIGN) = 60 - fromEnum (OP_SUBREF) = 59 + fromEnum (OP_SUBASSIGN) = 61 + fromEnum (OP_SUBREF) = 60 fromEnum (OP_TAN) = 15 - fromEnum (OP_TANH) = 38 - fromEnum (OP_TRANSPOSE) = 50 + fromEnum (OP_TANH) = 39 + fromEnum (OP_TRANSPOSE) = 51 fromEnum (OP_TWICE) = 12 - fromEnum (OP_VERTCAT) = 55 - fromEnum (OP_VERTSPLIT) = 57 - toEnum (73) = NUM_BUILT_IN_OPS + fromEnum (OP_VERTCAT) = 56 + fromEnum (OP_VERTSPLIT) = 58 + toEnum (74) = NUM_BUILT_IN_OPS toEnum (17) = OP_ACOS - toEnum (40) = OP_ACOSH + toEnum (41) = OP_ACOSH toEnum (1) = OP_ADD - toEnum (62) = OP_ADDNONZEROS + toEnum (63) = OP_ADDNONZEROS toEnum (24) = OP_AND toEnum (16) = OP_ASIN - toEnum (39) = OP_ASINH - toEnum (65) = OP_ASSERTION + toEnum (40) = OP_ASINH + toEnum (66) = OP_ASSERTION toEnum (0) = OP_ASSIGN toEnum (18) = OP_ATAN - toEnum (42) = OP_ATAN2 - toEnum (41) = OP_ATANH - toEnum (47) = OP_CALL + toEnum (43) = OP_ATAN2 + toEnum (42) = OP_ATANH + toEnum (48) = OP_CALL toEnum (27) = OP_CEIL - toEnum (43) = OP_CONST + toEnum (44) = OP_CONST toEnum (9) = OP_CONSTPOW - toEnum (30) = OP_COPYSIGN + toEnum (31) = OP_COPYSIGN toEnum (14) = OP_COS - toEnum (37) = OP_COSH - toEnum (51) = OP_DETERMINANT + toEnum (38) = OP_COSH + toEnum (52) = OP_DETERMINANT toEnum (4) = OP_DIV toEnum (21) = OP_EQ - toEnum (32) = OP_ERF - toEnum (70) = OP_ERFINV + toEnum (33) = OP_ERF + toEnum (71) = OP_ERFINV toEnum (6) = OP_EXP - toEnum (28) = OP_FABS + toEnum (29) = OP_FABS toEnum (26) = OP_FLOOR - toEnum (34) = OP_FMAX - toEnum (33) = OP_FMIN - toEnum (61) = OP_GETNONZEROS - toEnum (54) = OP_HORZCAT - toEnum (56) = OP_HORZSPLIT - toEnum (31) = OP_IF_ELSE_ZERO - toEnum (53) = OP_INNER_PROD - toEnum (44) = OP_INPUT - toEnum (35) = OP_INV - toEnum (52) = OP_INVERSE + toEnum (35) = OP_FMAX + toEnum (34) = OP_FMIN + toEnum (28) = OP_FMOD + toEnum (62) = OP_GETNONZEROS + toEnum (55) = OP_HORZCAT + toEnum (57) = OP_HORZSPLIT + toEnum (32) = OP_IF_ELSE_ZERO + toEnum (54) = OP_INNER_PROD + toEnum (45) = OP_INPUT + toEnum (36) = OP_INV + toEnum (53) = OP_INVERSE toEnum (20) = OP_LE - toEnum (72) = OP_LIFT + toEnum (73) = OP_LIFT toEnum (7) = OP_LOG toEnum (19) = OP_LT - toEnum (48) = OP_MATMUL + toEnum (49) = OP_MATMUL toEnum (3) = OP_MUL toEnum (22) = OP_NE toEnum (5) = OP_NEG - toEnum (67) = OP_NORM1 - toEnum (66) = OP_NORM2 - toEnum (69) = OP_NORMF - toEnum (68) = OP_NORMINF + toEnum (68) = OP_NORM1 + toEnum (67) = OP_NORM2 + toEnum (70) = OP_NORMF + toEnum (69) = OP_NORMINF toEnum (23) = OP_NOT toEnum (25) = OP_OR - toEnum (45) = OP_OUTPUT - toEnum (46) = OP_PARAMETER + toEnum (46) = OP_OUTPUT + toEnum (47) = OP_PARAMETER toEnum (8) = OP_POW - toEnum (71) = OP_PRINTME - toEnum (58) = OP_RESHAPE - toEnum (63) = OP_SETNONZEROS - toEnum (64) = OP_SET_SPARSE - toEnum (29) = OP_SIGN + toEnum (72) = OP_PRINTME + toEnum (59) = OP_RESHAPE + toEnum (64) = OP_SETNONZEROS + toEnum (65) = OP_SET_SPARSE + toEnum (30) = OP_SIGN toEnum (13) = OP_SIN - toEnum (36) = OP_SINH - toEnum (49) = OP_SOLVE + toEnum (37) = OP_SINH + toEnum (50) = OP_SOLVE toEnum (11) = OP_SQ toEnum (10) = OP_SQRT toEnum (2) = OP_SUB - toEnum (60) = OP_SUBASSIGN - toEnum (59) = OP_SUBREF + toEnum (61) = OP_SUBASSIGN + toEnum (60) = OP_SUBREF toEnum (15) = OP_TAN - toEnum (38) = OP_TANH - toEnum (50) = OP_TRANSPOSE + toEnum (39) = OP_TANH + toEnum (51) = OP_TRANSPOSE toEnum (12) = OP_TWICE - toEnum (55) = OP_VERTCAT - toEnum (57) = OP_VERTSPLIT + toEnum (56) = OP_VERTCAT + toEnum (58) = OP_VERTSPLIT toEnum k = error $ "Operation: toEnum: got unhandled number: " ++ show k instance Marshal Operation CInt where diff --git a/casadi-bindings-core.cabal b/casadi-bindings-core.cabal --- a/casadi-bindings-core.cabal +++ b/casadi-bindings-core.cabal @@ -1,5 +1,5 @@ name: casadi-bindings-core -version: 1.9.0.2 +version: 1.9.0.3 license: LGPL-3 license-file: LICENSE category: Numerical, Math diff --git a/cbits/autogen/core_classes.cpp b/cbits/autogen/core_classes.cpp --- a/cbits/autogen/core_classes.cpp +++ b/cbits/autogen/core_classes.cpp @@ -2960,6 +2960,32 @@ } +// ================== Normal method: "fmod" =============== +// class: "casadi::DMatrix" +// cppName: "casadi::DMatrix::fmod" +// cWrapperName: "casadi__DMatrix__fmod" +// protoArgs: "(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)" +// args: "(x0_)" +// rettype: UserType (Namespace ["casadi"]) (Name "DMatrix") +// cWrapperRetType: "casadi::DMatrix*" +// proto: "casadi::DMatrix* casadi__DMatrix__fmod(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0)" +// call: "obj->fmod(x0_)" +// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "DMatrix")))] +extern "C" + casadi::DMatrix* casadi__DMatrix__fmod(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0); +casadi::DMatrix* casadi__DMatrix__fmod(std::string ** err_msg, casadi::DMatrix* obj, casadi::DMatrix* x0){ + try { + casadi::DMatrix x0_ = Marshaling::marshal(x0); + + casadi::DMatrix ret = obj->fmod(x0_); + return WrapReturn< casadi::DMatrix*, casadi::DMatrix >::wrapReturn( ret ); + } catch (std::exception& ex) { + *err_msg = new std::string(ex.what()); + return 0; + } +} + + // ================== Normal method: "get" =============== // class: "casadi::DMatrix" // cppName: "casadi::DMatrix::get" @@ -14709,6 +14735,32 @@ } +// ================== Normal method: "fmod" =============== +// class: "casadi::IMatrix" +// cppName: "casadi::IMatrix::fmod" +// cWrapperName: "casadi__IMatrix__fmod" +// protoArgs: "(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)" +// args: "(x0_)" +// rettype: UserType (Namespace ["casadi"]) (Name "IMatrix") +// cWrapperRetType: "casadi::IMatrix*" +// proto: "casadi::IMatrix* casadi__IMatrix__fmod(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0)" +// call: "obj->fmod(x0_)" +// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "IMatrix")))] +extern "C" + casadi::IMatrix* casadi__IMatrix__fmod(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0); +casadi::IMatrix* casadi__IMatrix__fmod(std::string ** err_msg, casadi::IMatrix* obj, casadi::IMatrix* x0){ + try { + casadi::IMatrix x0_ = Marshaling::marshal(x0); + + casadi::IMatrix ret = obj->fmod(x0_); + return WrapReturn< casadi::IMatrix*, casadi::IMatrix >::wrapReturn( ret ); + } catch (std::exception& ex) { + *err_msg = new std::string(ex.what()); + return 0; + } +} + + // ================== Normal method: "get" =============== // class: "casadi::IMatrix" // cppName: "casadi::IMatrix::get" @@ -23848,6 +23900,32 @@ } +// ================== Normal method: "fmod" =============== +// class: "casadi::MX" +// cppName: "casadi::MX::fmod" +// cWrapperName: "casadi__MX__fmod" +// protoArgs: "(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)" +// args: "(x0_)" +// rettype: UserType (Namespace ["casadi"]) (Name "MX") +// cWrapperRetType: "casadi::MX*" +// proto: "casadi::MX* casadi__MX__fmod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0)" +// call: "obj->fmod(x0_)" +// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "MX")))] +extern "C" + casadi::MX* casadi__MX__fmod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0); +casadi::MX* casadi__MX__fmod(std::string ** err_msg, casadi::MX* obj, casadi::MX* x0){ + try { + casadi::MX x0_ = Marshaling::marshal(x0); + + casadi::MX ret = obj->fmod(x0_); + return WrapReturn< casadi::MX*, casadi::MX >::wrapReturn( ret ); + } catch (std::exception& ex) { + *err_msg = new std::string(ex.what()); + return 0; + } +} + + // ================== Normal method: "getDep" =============== // class: "casadi::MX" // cppName: "casadi::MX::getDep" @@ -33138,6 +33216,32 @@ } +// ================== Normal method: "fmod" =============== +// class: "casadi::SX" +// cppName: "casadi::SX::fmod" +// cWrapperName: "casadi__SX__fmod" +// protoArgs: "(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)" +// args: "(x0_)" +// rettype: UserType (Namespace ["casadi"]) (Name "SX") +// cWrapperRetType: "casadi::SX*" +// proto: "casadi::SX* casadi__SX__fmod(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0)" +// call: "obj->fmod(x0_)" +// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SX")))] +extern "C" + casadi::SX* casadi__SX__fmod(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0); +casadi::SX* casadi__SX__fmod(std::string ** err_msg, casadi::SX* obj, casadi::SX* x0){ + try { + casadi::SX x0_ = Marshaling::marshal(x0); + + casadi::SX ret = obj->fmod(x0_); + return WrapReturn< casadi::SX*, casadi::SX >::wrapReturn( ret ); + } catch (std::exception& ex) { + *err_msg = new std::string(ex.what()); + return 0; + } +} + + // ================== Normal method: "get" =============== // class: "casadi::SX" // cppName: "casadi::SX::get" @@ -40313,6 +40417,32 @@ casadi::SXElement x0_ = Marshaling::marshal(x0); casadi::SXElement ret = obj->fmin(x0_); + return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret ); + } catch (std::exception& ex) { + *err_msg = new std::string(ex.what()); + return 0; + } +} + + +// ================== Normal method: "fmod" =============== +// class: "casadi::SXElement" +// cppName: "casadi::SXElement::fmod" +// cWrapperName: "casadi__SXElement__fmod" +// protoArgs: "(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)" +// args: "(x0_)" +// rettype: UserType (Namespace ["casadi"]) (Name "SXElement") +// cWrapperRetType: "casadi::SXElement*" +// proto: "casadi::SXElement* casadi__SXElement__fmod(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0)" +// call: "obj->fmod(x0_)" +// params: [Ref (Const (UserType (Namespace ["casadi"]) (Name "SXElement")))] +extern "C" + casadi::SXElement* casadi__SXElement__fmod(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0); +casadi::SXElement* casadi__SXElement__fmod(std::string ** err_msg, casadi::SXElement* obj, casadi::SXElement* x0){ + try { + casadi::SXElement x0_ = Marshaling::marshal(x0); + + casadi::SXElement ret = obj->fmod(x0_); return WrapReturn< casadi::SXElement*, casadi::SXElement >::wrapReturn( ret ); } catch (std::exception& ex) { *err_msg = new std::string(ex.what());