From e7401cf874ea600ea244a26d2feb2c0db9baafd9 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Mon, 17 Dec 2018 15:15:41 +0100 Subject: [PATCH] generate_wrapper: include all cons_* headers - otherwise, constraints can not be created! --- gen/generate_wrapper.jl | 3 +- src/wrapper.jl | 34 ++++++ src/wrapper/commons.jl | 81 +++++++++++++ src/wrapper/cons_abspower.jl | 51 ++++++++ src/wrapper/cons_and.jl | 43 +++++++ src/wrapper/cons_benders.jl | 11 ++ src/wrapper/cons_benderslp.jl | 7 ++ src/wrapper/cons_bivariate.jl | 35 ++++++ src/wrapper/cons_bounddisjunction.jl | 31 +++++ src/wrapper/cons_cardinality.jl | 43 +++++++ src/wrapper/cons_components.jl | 7 ++ src/wrapper/cons_conjunction.jl | 19 +++ src/wrapper/cons_countsols.jl | 43 +++++++ src/wrapper/cons_cumulative.jl | 99 ++++++++++++++++ src/wrapper/cons_disjunction.jl | 19 +++ src/wrapper/cons_indicator.jl | 71 +++++++++++ src/wrapper/cons_integral.jl | 7 ++ src/wrapper/cons_knapsack.jl | 67 +++++++++++ src/wrapper/cons_linear.jl | 91 ++++++++++++++ src/wrapper/cons_linking.jl | 39 ++++++ src/wrapper/cons_logicor.jl | 39 ++++++ src/wrapper/cons_nonlinear.jl | 111 +++++++++++++++++ src/wrapper/cons_or.jl | 27 +++++ src/wrapper/cons_orbisack.jl | 23 ++++ src/wrapper/cons_orbitope.jl | 15 +++ src/wrapper/cons_pseudoboolean.jl | 71 +++++++++++ src/wrapper/cons_quadratic.jl | 171 +++++++++++++++++++++++++++ src/wrapper/cons_setppc.jl | 67 +++++++++++ src/wrapper/cons_soc.jl | 55 +++++++++ src/wrapper/cons_sos1.jl | 59 +++++++++ src/wrapper/cons_sos2.jl | 35 ++++++ src/wrapper/cons_superindicator.jl | 31 +++++ src/wrapper/cons_symresack.jl | 19 +++ src/wrapper/cons_varbound.jl | 47 ++++++++ src/wrapper/cons_xor.jl | 31 +++++ 35 files changed, 1601 insertions(+), 1 deletion(-) create mode 100644 src/wrapper/cons_abspower.jl create mode 100644 src/wrapper/cons_and.jl create mode 100644 src/wrapper/cons_benders.jl create mode 100644 src/wrapper/cons_benderslp.jl create mode 100644 src/wrapper/cons_bivariate.jl create mode 100644 src/wrapper/cons_bounddisjunction.jl create mode 100644 src/wrapper/cons_cardinality.jl create mode 100644 src/wrapper/cons_components.jl create mode 100644 src/wrapper/cons_conjunction.jl create mode 100644 src/wrapper/cons_countsols.jl create mode 100644 src/wrapper/cons_cumulative.jl create mode 100644 src/wrapper/cons_disjunction.jl create mode 100644 src/wrapper/cons_indicator.jl create mode 100644 src/wrapper/cons_integral.jl create mode 100644 src/wrapper/cons_knapsack.jl create mode 100644 src/wrapper/cons_linear.jl create mode 100644 src/wrapper/cons_linking.jl create mode 100644 src/wrapper/cons_logicor.jl create mode 100644 src/wrapper/cons_nonlinear.jl create mode 100644 src/wrapper/cons_or.jl create mode 100644 src/wrapper/cons_orbisack.jl create mode 100644 src/wrapper/cons_orbitope.jl create mode 100644 src/wrapper/cons_pseudoboolean.jl create mode 100644 src/wrapper/cons_quadratic.jl create mode 100644 src/wrapper/cons_setppc.jl create mode 100644 src/wrapper/cons_soc.jl create mode 100644 src/wrapper/cons_sos1.jl create mode 100644 src/wrapper/cons_sos2.jl create mode 100644 src/wrapper/cons_superindicator.jl create mode 100644 src/wrapper/cons_symresack.jl create mode 100644 src/wrapper/cons_varbound.jl create mode 100644 src/wrapper/cons_xor.jl diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index b993496e..70e0fa06 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -6,7 +6,8 @@ scip_headers = vcat( filter(h -> startswith(h, "type_"), all_headers), # filter(h -> startswith(h, "pub_"), all_headers), filter(h -> startswith(h, "scip_"), all_headers), - "scipdefplugins.h" + "scipdefplugins.h", + filter(h -> startswith(h, "cons_"), all_headers), ) lpi_headers = ["type_lpi.h"] nlpi_headers = ["type_expr.h", "type_nlpi.h"] diff --git a/src/wrapper.jl b/src/wrapper.jl index b0e5a9a4..9c581aa6 100644 --- a/src/wrapper.jl +++ b/src/wrapper.jl @@ -56,3 +56,37 @@ include(wrap("scip_var")) # default SCIP plugins include(wrap("scipdefplugins")) + +# all constraint types +include(wrap("cons_abspower")) +include(wrap("cons_and")) +include(wrap("cons_benders")) +include(wrap("cons_benderslp")) +include(wrap("cons_bivariate")) +include(wrap("cons_bounddisjunction")) +include(wrap("cons_cardinality")) +include(wrap("cons_components")) +include(wrap("cons_conjunction")) +include(wrap("cons_countsols")) +include(wrap("cons_cumulative")) +include(wrap("cons_disjunction")) +include(wrap("cons_indicator")) +include(wrap("cons_integral")) +include(wrap("cons_knapsack")) +include(wrap("cons_linear")) +include(wrap("cons_linking")) +include(wrap("cons_logicor")) +include(wrap("cons_nonlinear")) +include(wrap("cons_orbisack")) +include(wrap("cons_orbitope")) +include(wrap("cons_or")) +include(wrap("cons_pseudoboolean")) +include(wrap("cons_quadratic")) +include(wrap("cons_setppc")) +include(wrap("cons_soc")) +include(wrap("cons_sos1")) +include(wrap("cons_sos2")) +include(wrap("cons_superindicator")) +include(wrap("cons_symresack")) +include(wrap("cons_varbound")) +include(wrap("cons_xor")) diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index 67e197fc..589df564 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -1174,6 +1174,87 @@ const SCIP_VISUAL = SCIP_Visual # Skipping MacroDefinition: SCIPdebugMsg ( scip , ... ) while ( FALSE ) SCIPprintDebugMessage ( scip , __FILE__ , __LINE__ , __VA_ARGS__ ) # Skipping MacroDefinition: SCIPdebugMsgPrint ( scip , ... ) while ( FALSE ) SCIPdebugMessagePrint ( scip , __VA_ARGS__ ) +@cenum(SCIP_BIVAR_CONVEXITY, + SCIP_BIVAR_ALLCONVEX = 0, + SCIP_BIVAR_1CONVEX_INDEFINITE = 1, + SCIP_BIVAR_CONVEX_CONCAVE = 2, + SCIP_BIVAR_UNKNOWN = 3, +) + +# Skipping MacroDefinition: SCIP_DECL_SOLVECUMULATIVE ( x ) SCIP_RETCODE x ( int njobs , SCIP_Real * ests , SCIP_Real * lsts , SCIP_Real * objvals , int * durations , int * demands , int capacity , int hmin , int hmax , SCIP_Real timelimit , SCIP_Real memorylimit , SCIP_Longint maxnodes , SCIP_Bool * solved , SCIP_Bool * infeasible , SCIP_Bool * unbounded , SCIP_Bool * error ) +# Skipping MacroDefinition: SCIP_DECL_LINCONSUPGD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONS * cons , int nvars , SCIP_VAR * * vars , SCIP_Real * vals , SCIP_Real lhs , SCIP_Real rhs , int nposbin , int nnegbin , int nposint , int nnegint , int nposimpl , int nnegimpl , int nposimplbin , int nnegimplbin , int nposcont , int nnegcont , int ncoeffspone , int ncoeffsnone , int ncoeffspint , int ncoeffsnint , int ncoeffspfrac , int ncoeffsnfrac , SCIP_Real poscoeffsum , SCIP_Real negcoeffsum , SCIP_Bool integral , SCIP_CONS * * upgdcons ) + +const SCIP_LinConsUpgrade = Cvoid +const SCIP_LINCONSUPGRADE = SCIP_LinConsUpgrade + +# Skipping MacroDefinition: SCIP_DECL_NONLINCONSUPGD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONS * cons , int * nupgdconss , SCIP_CONS * * upgdconss , int upgdconsssize ) +# Skipping MacroDefinition: SCIP_DECL_EXPRGRAPHNODEREFORM ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EXPRGRAPH * exprgraph , SCIP_EXPRGRAPHNODE * node , int * naddcons , SCIP_EXPRGRAPHNODE * * reformnode ) + +@cenum(SCIP_OrbitopeType, + SCIP_ORBITOPETYPE_FULL = 0, + SCIP_ORBITOPETYPE_PARTITIONING = 1, + SCIP_ORBITOPETYPE_PACKING = 2, +) + +const SCIP_ORBITOPETYPE = SCIP_OrbitopeType +const ARTIFICIALVARNAMEPREFIX = "andresultant_" + +@cenum(SCIP_LinearConsType{Int32}, + SCIP_LINEARCONSTYPE_INVALIDCONS = -1, + SCIP_LINEARCONSTYPE_LINEAR = 0, + SCIP_LINEARCONSTYPE_LOGICOR = 1, + SCIP_LINEARCONSTYPE_KNAPSACK = 2, + SCIP_LINEARCONSTYPE_SETPPC = 3, +) + +const SCIP_LINEARCONSTYPE = SCIP_LinearConsType + +# Skipping MacroDefinition: SCIP_DECL_QUADCONSUPGD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONS * cons , int nbinlin , int nbinquad , int nintlin , int nintquad , int nimpllin , int nimplquad , int ncontlin , int ncontquad , SCIP_Bool integral , int * nupgdconss , SCIP_CONS * * upgdconss , int upgdconsssize , SCIP_PRESOLTIMING presoltiming ) + +const SCIP_QuadVarEventData = Cvoid +const SCIP_QUADVAREVENTDATA = SCIP_QuadVarEventData + +struct SCIP_QuadVarTerm + var::Ptr{SCIP_VAR} + lincoef::Cdouble + sqrcoef::Cdouble + nadjbilin::Cint + adjbilinsize::Cint + adjbilin::Ptr{Cint} + eventdata::Ptr{SCIP_QUADVAREVENTDATA} +end + +const SCIP_QUADVARTERM = SCIP_QuadVarTerm + +struct SCIP_BilinTerm + var1::Ptr{SCIP_VAR} + var2::Ptr{SCIP_VAR} + coef::Cdouble +end + +const SCIP_BILINTERM = SCIP_BilinTerm + +struct SCIP_RowPrep + vars::Ptr{Ptr{SCIP_VAR}} + coefs::Ptr{Cdouble} + nvars::Cint + varssize::Cint + side::Cdouble + sidetype::SCIP_SIDETYPE + _local::UInt32 + name::NTuple{1024, UInt8} +end + +const SCIP_ROWPREP = SCIP_RowPrep + +@cenum(SCIP_SetppcType, + SCIP_SETPPCTYPE_PARTITIONING = 0, + SCIP_SETPPCTYPE_PACKING = 1, + SCIP_SETPPCTYPE_COVERING = 2, +) + +const SCIP_SETPPCTYPE = SCIP_SetppcType + @cenum(SCIP_ObjSen{Int32}, SCIP_OBJSEN_MAXIMIZE = -1, SCIP_OBJSEN_MINIMIZE = 1, diff --git a/src/wrapper/cons_abspower.jl b/src/wrapper/cons_abspower.jl new file mode 100644 index 00000000..16ed9474 --- /dev/null +++ b/src/wrapper/cons_abspower.jl @@ -0,0 +1,51 @@ +# Julia wrapper for header: /usr/include/scip/cons_abspower.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrAbspower(scip) + ccall((:SCIPincludeConshdlrAbspower, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsAbspower(scip, cons, name, x, z, exponent, xoffset, zcoef, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsAbspower, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, x, z, exponent, xoffset, zcoef, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicAbspower(scip, cons, name, x, z, exponent, xoffset, zcoef, lhs, rhs) + ccall((:SCIPcreateConsBasicAbspower, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, cons, name, x, z, exponent, xoffset, zcoef, lhs, rhs) +end + +function SCIPgetNlRowAbspower(scip, cons, nlrow) + ccall((:SCIPgetNlRowAbspower, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_NLROW}}), scip, cons, nlrow) +end + +function SCIPgetNonlinearVarAbspower(scip, cons) + ccall((:SCIPgetNonlinearVarAbspower, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinearVarAbspower(scip, cons) + ccall((:SCIPgetLinearVarAbspower, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetExponentAbspower(scip, cons) + ccall((:SCIPgetExponentAbspower, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetOffsetAbspower(scip, cons) + ccall((:SCIPgetOffsetAbspower, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetCoefLinearAbspower(scip, cons) + ccall((:SCIPgetCoefLinearAbspower, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLhsAbspower(scip, cons) + ccall((:SCIPgetLhsAbspower, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsAbspower(scip, cons) + ccall((:SCIPgetRhsAbspower, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetViolationAbspower(scip, cons, sol) + ccall((:SCIPgetViolationAbspower, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}), scip, cons, sol) +end diff --git a/src/wrapper/cons_and.jl b/src/wrapper/cons_and.jl new file mode 100644 index 00000000..996457e6 --- /dev/null +++ b/src/wrapper/cons_and.jl @@ -0,0 +1,43 @@ +# Julia wrapper for header: /usr/include/scip/cons_and.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrAnd(scip) + ccall((:SCIPincludeConshdlrAnd, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsAnd(scip, cons, name, resvar, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsAnd, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, resvar, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicAnd(scip, cons, name, resvar, nvars, vars) + ccall((:SCIPcreateConsBasicAnd, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, resvar, nvars, vars) +end + +function SCIPgetNVarsAnd(scip, cons) + ccall((:SCIPgetNVarsAnd, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsAnd(scip, cons) + ccall((:SCIPgetVarsAnd, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetResultantAnd(scip, cons) + ccall((:SCIPgetResultantAnd, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPisAndConsSorted(scip, cons) + ccall((:SCIPisAndConsSorted, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPsortAndCons(scip, cons) + ccall((:SCIPsortAndCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPchgAndConsCheckFlagWhenUpgr(scip, cons, flag) + ccall((:SCIPchgAndConsCheckFlagWhenUpgr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, flag) +end + +function SCIPchgAndConsRemovableFlagWhenUpgr(scip, cons, flag) + ccall((:SCIPchgAndConsRemovableFlagWhenUpgr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, flag) +end diff --git a/src/wrapper/cons_benders.jl b/src/wrapper/cons_benders.jl new file mode 100644 index 00000000..b802b337 --- /dev/null +++ b/src/wrapper/cons_benders.jl @@ -0,0 +1,11 @@ +# Julia wrapper for header: /usr/include/scip/cons_benders.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrBenders(scip) + ccall((:SCIPincludeConshdlrBenders, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPconsBendersEnforceSolution(scip, sol, conshdlr, result, type, checkint) + ccall((:SCIPconsBendersEnforceSolution, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_RESULT}, SCIP_BENDERSENFOTYPE, UInt32), scip, sol, conshdlr, result, type, checkint) +end diff --git a/src/wrapper/cons_benderslp.jl b/src/wrapper/cons_benderslp.jl new file mode 100644 index 00000000..96b905c6 --- /dev/null +++ b/src/wrapper/cons_benderslp.jl @@ -0,0 +1,7 @@ +# Julia wrapper for header: /usr/include/scip/cons_benderslp.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrBenderslp(scip) + ccall((:SCIPincludeConshdlrBenderslp, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end diff --git a/src/wrapper/cons_bivariate.jl b/src/wrapper/cons_bivariate.jl new file mode 100644 index 00000000..3aa03280 --- /dev/null +++ b/src/wrapper/cons_bivariate.jl @@ -0,0 +1,35 @@ +# Julia wrapper for header: /usr/include/scip/cons_bivariate.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrBivariate(scip) + ccall((:SCIPincludeConshdlrBivariate, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsBivariate(scip, cons, name, f, convextype, z, zcoef, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsBivariate, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_EXPRTREE}, SCIP_BIVAR_CONVEXITY, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, f, convextype, z, zcoef, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicBivariate(scip, cons, name, f, convextype, z, zcoef, lhs, rhs) + ccall((:SCIPcreateConsBasicBivariate, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_EXPRTREE}, SCIP_BIVAR_CONVEXITY, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, cons, name, f, convextype, z, zcoef, lhs, rhs) +end + +function SCIPgetLinearVarBivariate(scip, cons) + ccall((:SCIPgetLinearVarBivariate, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinearCoefBivariate(scip, cons) + ccall((:SCIPgetLinearCoefBivariate, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetExprtreeBivariate(scip, cons) + ccall((:SCIPgetExprtreeBivariate, libscip), Ptr{SCIP_EXPRTREE}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLhsBivariate(scip, cons) + ccall((:SCIPgetLhsBivariate, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsBivariate(scip, cons) + ccall((:SCIPgetRhsBivariate, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_bounddisjunction.jl b/src/wrapper/cons_bounddisjunction.jl new file mode 100644 index 00000000..71444df1 --- /dev/null +++ b/src/wrapper/cons_bounddisjunction.jl @@ -0,0 +1,31 @@ +# Julia wrapper for header: /usr/include/scip/cons_bounddisjunction.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrBounddisjunction(scip) + ccall((:SCIPincludeConshdlrBounddisjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsBounddisjunction(scip, cons, name, nvars, vars, boundtypes, bounds, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsBounddisjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, boundtypes, bounds, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicBounddisjunction(scip, cons, name, nvars, vars, boundtypes, bounds) + ccall((:SCIPcreateConsBasicBounddisjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}), scip, cons, name, nvars, vars, boundtypes, bounds) +end + +function SCIPgetNVarsBounddisjunction(scip, cons) + ccall((:SCIPgetNVarsBounddisjunction, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsBounddisjunction(scip, cons) + ccall((:SCIPgetVarsBounddisjunction, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetBoundtypesBounddisjunction(scip, cons) + ccall((:SCIPgetBoundtypesBounddisjunction, libscip), Ptr{SCIP_BOUNDTYPE}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetBoundsBounddisjunction(scip, cons) + ccall((:SCIPgetBoundsBounddisjunction, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_cardinality.jl b/src/wrapper/cons_cardinality.jl new file mode 100644 index 00000000..affc2cdf --- /dev/null +++ b/src/wrapper/cons_cardinality.jl @@ -0,0 +1,43 @@ +# Julia wrapper for header: /usr/include/scip/cons_cardinality.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrCardinality(scip) + ccall((:SCIPincludeConshdlrCardinality, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsCardinality(scip, cons, name, nvars, vars, cardval, indvars, weights, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsCardinality, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, cardval, indvars, weights, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicCardinality(scip, cons, name, nvars, vars, cardval, indvars, weights) + ccall((:SCIPcreateConsBasicCardinality, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, name, nvars, vars, cardval, indvars, weights) +end + +function SCIPchgCardvalCardinality(scip, cons, cardval) + ccall((:SCIPchgCardvalCardinality, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cint), scip, cons, cardval) +end + +function SCIPaddVarCardinality(scip, cons, var, indvar, weight) + ccall((:SCIPaddVarCardinality, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, indvar, weight) +end + +function SCIPappendVarCardinality(scip, cons, var, indvar) + ccall((:SCIPappendVarCardinality, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), scip, cons, var, indvar) +end + +function SCIPgetNVarsCardinality(scip, cons) + ccall((:SCIPgetNVarsCardinality, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsCardinality(scip, cons) + ccall((:SCIPgetVarsCardinality, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetCardvalCardinality(scip, cons) + ccall((:SCIPgetCardvalCardinality, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetWeightsCardinality(scip, cons) + ccall((:SCIPgetWeightsCardinality, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_components.jl b/src/wrapper/cons_components.jl new file mode 100644 index 00000000..c6dee265 --- /dev/null +++ b/src/wrapper/cons_components.jl @@ -0,0 +1,7 @@ +# Julia wrapper for header: /usr/include/scip/cons_components.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrComponents(scip) + ccall((:SCIPincludeConshdlrComponents, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end diff --git a/src/wrapper/cons_conjunction.jl b/src/wrapper/cons_conjunction.jl new file mode 100644 index 00000000..221eebca --- /dev/null +++ b/src/wrapper/cons_conjunction.jl @@ -0,0 +1,19 @@ +# Julia wrapper for header: /usr/include/scip/cons_conjunction.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrConjunction(scip) + ccall((:SCIPincludeConshdlrConjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsConjunction(scip, cons, name, nconss, conss, enforce, check, _local, modifiable, dynamic) + ccall((:SCIPcreateConsConjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_CONS}}, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nconss, conss, enforce, check, _local, modifiable, dynamic) +end + +function SCIPcreateConsBasicConjunction(scip, cons, name, nconss, conss) + ccall((:SCIPcreateConsBasicConjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_CONS}}), scip, cons, name, nconss, conss) +end + +function SCIPaddConsElemConjunction(scip, cons, addcons) + ccall((:SCIPaddConsElemConjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons, addcons) +end diff --git a/src/wrapper/cons_countsols.jl b/src/wrapper/cons_countsols.jl new file mode 100644 index 00000000..8211aad8 --- /dev/null +++ b/src/wrapper/cons_countsols.jl @@ -0,0 +1,43 @@ +# Julia wrapper for header: /usr/include/scip/cons_countsols.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrCountsols(scip) + ccall((:SCIPincludeConshdlrCountsols, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPdialogExecCountPresolve(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecCountPresolve, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecCount(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecCount, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecWriteAllsolutions(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecWriteAllsolutions, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPcount(scip) + ccall((:SCIPcount, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPgetNCountedSols(scip, valid) + ccall((:SCIPgetNCountedSols, libscip), Clonglong, (Ptr{SCIP_}, Ptr{UInt32}), scip, valid) +end + +function SCIPgetNCountedSolsstr(scip, buffer, buffersize, requiredsize) + ccall((:SCIPgetNCountedSolsstr, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Cstring}, Cint, Ptr{Cint}), scip, buffer, buffersize, requiredsize) +end + +function SCIPgetNCountedFeasSubtrees(scip) + ccall((:SCIPgetNCountedFeasSubtrees, libscip), Clonglong, (Ptr{SCIP_},), scip) +end + +function SCIPgetCountedSparseSols(scip, vars, nvars, sols, nsols) + ccall((:SCIPgetCountedSparseSols, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Ptr{Ptr{SCIP_SPARSESOL}}}, Ptr{Cint}), scip, vars, nvars, sols, nsols) +end + +function SCIPsetParamsCountsols(scip) + ccall((:SCIPsetParamsCountsols, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end diff --git a/src/wrapper/cons_cumulative.jl b/src/wrapper/cons_cumulative.jl new file mode 100644 index 00000000..278b6907 --- /dev/null +++ b/src/wrapper/cons_cumulative.jl @@ -0,0 +1,99 @@ +# Julia wrapper for header: /usr/include/scip/cons_cumulative.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrCumulative(scip) + ccall((:SCIPincludeConshdlrCumulative, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsCumulative(scip, cons, name, nvars, vars, durations, demands, capacity, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsCumulative, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, durations, demands, capacity, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicCumulative(scip, cons, name, nvars, vars, durations, demands, capacity) + ccall((:SCIPcreateConsBasicCumulative, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint), scip, cons, name, nvars, vars, durations, demands, capacity) +end + +function SCIPsetHminCumulative(scip, cons, hmin) + ccall((:SCIPsetHminCumulative, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cint), scip, cons, hmin) +end + +function SCIPgetHminCumulative(scip, cons) + ccall((:SCIPgetHminCumulative, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPsetHmaxCumulative(scip, cons, hmax) + ccall((:SCIPsetHmaxCumulative, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cint), scip, cons, hmax) +end + +function SCIPgetHmaxCumulative(scip, cons) + ccall((:SCIPgetHmaxCumulative, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsCumulative(scip, cons) + ccall((:SCIPgetVarsCumulative, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetNVarsCumulative(scip, cons) + ccall((:SCIPgetNVarsCumulative, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetCapacityCumulative(scip, cons) + ccall((:SCIPgetCapacityCumulative, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDurationsCumulative(scip, cons) + ccall((:SCIPgetDurationsCumulative, libscip), Ptr{Cint}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDemandsCumulative(scip, cons) + ccall((:SCIPgetDemandsCumulative, libscip), Ptr{Cint}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPcheckCumulativeCondition(scip, sol, nvars, vars, durations, demands, capacity, hmin, hmax, violated, cons, printreason) + ccall((:SCIPcheckCumulativeCondition, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint, Cint, Cint, Ptr{UInt32}, Ptr{SCIP_CONS}, UInt32), scip, sol, nvars, vars, durations, demands, capacity, hmin, hmax, violated, cons, printreason) +end + +function SCIPnormalizeCumulativeCondition(scip, nvars, vars, durations, demands, capacity, nchgcoefs, nchgsides) + ccall((:SCIPnormalizeCumulativeCondition, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, nvars, vars, durations, demands, capacity, nchgcoefs, nchgsides) +end + +function SCIPsplitCumulativeCondition(scip, nvars, vars, durations, demands, capacity, hmin, hmax, split) + ccall((:SCIPsplitCumulativeCondition, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, nvars, vars, durations, demands, capacity, hmin, hmax, split) +end + +function SCIPpresolveCumulativeCondition(scip, nvars, vars, durations, hmin, hmax, downlocks, uplocks, cons, delvars, nfixedvars, nchgsides, cutoff) + ccall((:SCIPpresolveCumulativeCondition, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Cint, Ptr{UInt32}, Ptr{UInt32}, Ptr{SCIP_CONS}, Ptr{UInt32}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}), scip, nvars, vars, durations, hmin, hmax, downlocks, uplocks, cons, delvars, nfixedvars, nchgsides, cutoff) +end + +function SCIPpropCumulativeCondition(scip, presoltiming, nvars, vars, durations, demands, capacity, hmin, hmax, cons, nchgbds, initialized, explanation, cutoff) + ccall((:SCIPpropCumulativeCondition, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_PRESOLTIMING, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint, Cint, Cint, Ptr{SCIP_CONS}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, presoltiming, nvars, vars, durations, demands, capacity, hmin, hmax, cons, nchgbds, initialized, explanation, cutoff) +end + +function SCIPrespropCumulativeCondition(scip, nvars, vars, durations, demands, capacity, hmin, hmax, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, explanation, result) + ccall((:SCIPrespropCumulativeCondition, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint, Cint, Cint, Ptr{SCIP_VAR}, Cint, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble, Ptr{UInt32}, Ptr{SCIP_RESULT}), scip, nvars, vars, durations, demands, capacity, hmin, hmax, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, explanation, result) +end + +function SCIPvisualizeConsCumulative(scip, cons) + ccall((:SCIPvisualizeConsCumulative, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPsetSolveCumulative(scip, solveCumulative) + ccall((:SCIPsetSolveCumulative, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}), scip, solveCumulative) +end + +function SCIPsolveCumulative(scip, njobs, ests, lsts, objvals, durations, demands, capacity, hmin, hmax, timelimit, memorylimit, maxnodes, solved, infeasible, unbounded, error) + ccall((:SCIPsolveCumulative, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Cint, Cint, Cdouble, Cdouble, Clonglong, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, njobs, ests, lsts, objvals, durations, demands, capacity, hmin, hmax, timelimit, memorylimit, maxnodes, solved, infeasible, unbounded, error) +end + +function SCIPcreateWorstCaseProfile(scip, profile, nvars, vars, durations, demands) + ccall((:SCIPcreateWorstCaseProfile, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROFILE}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}), scip, profile, nvars, vars, durations, demands) +end + +function SCIPcomputeHmin(scip, profile, capacity) + ccall((:SCIPcomputeHmin, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_PROFILE}, Cint), scip, profile, capacity) +end + +function SCIPcomputeHmax(scip, profile, capacity) + ccall((:SCIPcomputeHmax, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_PROFILE}, Cint), scip, profile, capacity) +end diff --git a/src/wrapper/cons_disjunction.jl b/src/wrapper/cons_disjunction.jl new file mode 100644 index 00000000..cfd086af --- /dev/null +++ b/src/wrapper/cons_disjunction.jl @@ -0,0 +1,19 @@ +# Julia wrapper for header: /usr/include/scip/cons_disjunction.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrDisjunction(scip) + ccall((:SCIPincludeConshdlrDisjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsDisjunction(scip, cons, name, nconss, conss, relaxcons, initial, enforce, check, _local, modifiable, dynamic) + ccall((:SCIPcreateConsDisjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONS}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nconss, conss, relaxcons, initial, enforce, check, _local, modifiable, dynamic) +end + +function SCIPcreateConsBasicDisjunction(scip, cons, name, nconss, conss, relaxcons) + ccall((:SCIPcreateConsBasicDisjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONS}), scip, cons, name, nconss, conss, relaxcons) +end + +function SCIPaddConsElemDisjunction(scip, cons, addcons) + ccall((:SCIPaddConsElemDisjunction, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons, addcons) +end diff --git a/src/wrapper/cons_indicator.jl b/src/wrapper/cons_indicator.jl new file mode 100644 index 00000000..915d2ee6 --- /dev/null +++ b/src/wrapper/cons_indicator.jl @@ -0,0 +1,71 @@ +# Julia wrapper for header: /usr/include/scip/cons_indicator.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrIndicator(scip) + ccall((:SCIPincludeConshdlrIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsIndicator(scip, cons, name, binvar, nvars, vars, vals, rhs, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, binvar, nvars, vars, vals, rhs, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicIndicator(scip, cons, name, binvar, nvars, vars, vals, rhs) + ccall((:SCIPcreateConsBasicIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble), scip, cons, name, binvar, nvars, vars, vals, rhs) +end + +function SCIPcreateConsIndicatorLinCons(scip, cons, name, binvar, lincons, slackvar, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsIndicatorLinCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, binvar, lincons, slackvar, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicIndicatorLinCons(scip, cons, name, binvar, lincons, slackvar) + ccall((:SCIPcreateConsBasicIndicatorLinCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, name, binvar, lincons, slackvar) +end + +function SCIPaddVarIndicator(scip, cons, var, val) + ccall((:SCIPaddVarIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, val) +end + +function SCIPgetLinearConsIndicator(cons) + ccall((:SCIPgetLinearConsIndicator, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_CONS},), cons) +end + +function SCIPsetLinearConsIndicator(scip, cons, lincons) + ccall((:SCIPsetLinearConsIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons, lincons) +end + +function SCIPsetBinaryVarIndicator(scip, cons, binvar) + ccall((:SCIPsetBinaryVarIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, binvar) +end + +function SCIPgetBinaryVarIndicator(cons) + ccall((:SCIPgetBinaryVarIndicator, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_CONS},), cons) +end + +function SCIPgetSlackVarIndicator(cons) + ccall((:SCIPgetSlackVarIndicator, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_CONS},), cons) +end + +function SCIPsetSlackVarUb(scip, cons, ub) + ccall((:SCIPsetSlackVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, ub) +end + +function SCIPisViolatedIndicator(scip, cons, sol) + ccall((:SCIPisViolatedIndicator, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}), scip, cons, sol) +end + +function SCIPmakeIndicatorFeasible(scip, cons, sol, changed) + ccall((:SCIPmakeIndicatorFeasible, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, cons, sol, changed) +end + +function SCIPmakeIndicatorsFeasible(scip, conshdlr, sol, changed) + ccall((:SCIPmakeIndicatorsFeasible, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, conshdlr, sol, changed) +end + +function SCIPaddLinearConsIndicator(scip, conshdlr, lincons) + ccall((:SCIPaddLinearConsIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONS}), scip, conshdlr, lincons) +end + +function SCIPaddRowIndicator(scip, conshdlr, row) + ccall((:SCIPaddRowIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_ROW}), scip, conshdlr, row) +end diff --git a/src/wrapper/cons_integral.jl b/src/wrapper/cons_integral.jl new file mode 100644 index 00000000..617e12f6 --- /dev/null +++ b/src/wrapper/cons_integral.jl @@ -0,0 +1,7 @@ +# Julia wrapper for header: /usr/include/scip/cons_integral.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrIntegral(scip) + ccall((:SCIPincludeConshdlrIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end diff --git a/src/wrapper/cons_knapsack.jl b/src/wrapper/cons_knapsack.jl new file mode 100644 index 00000000..91a4f48a --- /dev/null +++ b/src/wrapper/cons_knapsack.jl @@ -0,0 +1,67 @@ +# Julia wrapper for header: /usr/include/scip/cons_knapsack.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrKnapsack(scip) + ccall((:SCIPincludeConshdlrKnapsack, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsKnapsack(scip, cons, name, nvars, vars, weights, capacity, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsKnapsack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Clonglong}, Clonglong, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, weights, capacity, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicKnapsack(scip, cons, name, nvars, vars, weights, capacity) + ccall((:SCIPcreateConsBasicKnapsack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Clonglong}, Clonglong), scip, cons, name, nvars, vars, weights, capacity) +end + +function SCIPaddCoefKnapsack(scip, cons, var, weight) + ccall((:SCIPaddCoefKnapsack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Clonglong), scip, cons, var, weight) +end + +function SCIPgetCapacityKnapsack(scip, cons) + ccall((:SCIPgetCapacityKnapsack, libscip), Clonglong, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPchgCapacityKnapsack(scip, cons, capacity) + ccall((:SCIPchgCapacityKnapsack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Clonglong), scip, cons, capacity) +end + +function SCIPgetNVarsKnapsack(scip, cons) + ccall((:SCIPgetNVarsKnapsack, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsKnapsack(scip, cons) + ccall((:SCIPgetVarsKnapsack, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetWeightsKnapsack(scip, cons) + ccall((:SCIPgetWeightsKnapsack, libscip), Ptr{Clonglong}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualsolKnapsack(scip, cons) + ccall((:SCIPgetDualsolKnapsack, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualfarkasKnapsack(scip, cons) + ccall((:SCIPgetDualfarkasKnapsack, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRowKnapsack(scip, cons) + ccall((:SCIPgetRowKnapsack, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPsolveKnapsackExactly(scip, nitems, weights, profits, capacity, items, solitems, nonsolitems, nsolitems, nnonsolitems, solval, success) + ccall((:SCIPsolveKnapsackExactly, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Clonglong}, Ptr{Cdouble}, Clonglong, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{UInt32}), scip, nitems, weights, profits, capacity, items, solitems, nonsolitems, nsolitems, nnonsolitems, solval, success) +end + +function SCIPsolveKnapsackApproximately(scip, nitems, weights, profits, capacity, items, solitems, nonsolitems, nsolitems, nnonsolitems, solval) + ccall((:SCIPsolveKnapsackApproximately, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Clonglong}, Ptr{Cdouble}, Clonglong, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), scip, nitems, weights, profits, capacity, items, solitems, nonsolitems, nsolitems, nnonsolitems, solval) +end + +function SCIPseparateKnapsackCuts(scip, cons, sepa, vars, nvars, weights, capacity, sol, usegubs, cutoff, ncuts) + ccall((:SCIPseparateKnapsackCuts, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SEPA}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Clonglong}, Clonglong, Ptr{SCIP_SOL}, UInt32, Ptr{UInt32}, Ptr{Cint}), scip, cons, sepa, vars, nvars, weights, capacity, sol, usegubs, cutoff, ncuts) +end + +function SCIPseparateRelaxedKnapsack(scip, cons, sepa, nknapvars, knapvars, knapvals, valscale, rhs, sol, cutoff, ncuts) + ccall((:SCIPseparateRelaxedKnapsack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SEPA}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Ptr{SCIP_SOL}, Ptr{UInt32}, Ptr{Cint}), scip, cons, sepa, nknapvars, knapvars, knapvals, valscale, rhs, sol, cutoff, ncuts) +end diff --git a/src/wrapper/cons_linear.jl b/src/wrapper/cons_linear.jl new file mode 100644 index 00000000..9a429b11 --- /dev/null +++ b/src/wrapper/cons_linear.jl @@ -0,0 +1,91 @@ +# Julia wrapper for header: /usr/include/scip/cons_linear.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrLinear(scip) + ccall((:SCIPincludeConshdlrLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPincludeLinconsUpgrade(scip, linconsupgd, priority, conshdlrname) + ccall((:SCIPincludeLinconsUpgrade, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}, Cint, Cstring), scip, linconsupgd, priority, conshdlrname) +end + +function SCIPcreateConsLinear(scip, cons, name, nvars, vars, vals, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, vals, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicLinear(scip, cons, name, nvars, vars, vals, lhs, rhs) + ccall((:SCIPcreateConsBasicLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble), scip, cons, name, nvars, vars, vals, lhs, rhs) +end + +function SCIPcopyConsLinear(scip, cons, sourcescip, name, nvars, sourcevars, sourcecoefs, lhs, rhs, varmap, consmap, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) + ccall((:SCIPcopyConsLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, cons, sourcescip, name, nvars, sourcevars, sourcecoefs, lhs, rhs, varmap, consmap, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) +end + +function SCIPaddCoefLinear(scip, cons, var, val) + ccall((:SCIPaddCoefLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, val) +end + +function SCIPchgCoefLinear(scip, cons, var, val) + ccall((:SCIPchgCoefLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, val) +end + +function SCIPdelCoefLinear(scip, cons, var) + ccall((:SCIPdelCoefLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, var) +end + +function SCIPgetLhsLinear(scip, cons) + ccall((:SCIPgetLhsLinear, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsLinear(scip, cons) + ccall((:SCIPgetRhsLinear, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPchgLhsLinear(scip, cons, lhs) + ccall((:SCIPchgLhsLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, lhs) +end + +function SCIPchgRhsLinear(scip, cons, rhs) + ccall((:SCIPchgRhsLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, rhs) +end + +function SCIPgetNVarsLinear(scip, cons) + ccall((:SCIPgetNVarsLinear, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsLinear(scip, cons) + ccall((:SCIPgetVarsLinear, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetValsLinear(scip, cons) + ccall((:SCIPgetValsLinear, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetActivityLinear(scip, cons, sol) + ccall((:SCIPgetActivityLinear, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}), scip, cons, sol) +end + +function SCIPgetFeasibilityLinear(scip, cons, sol) + ccall((:SCIPgetFeasibilityLinear, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}), scip, cons, sol) +end + +function SCIPgetDualsolLinear(scip, cons) + ccall((:SCIPgetDualsolLinear, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualfarkasLinear(scip, cons) + ccall((:SCIPgetDualfarkasLinear, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRowLinear(scip, cons) + ccall((:SCIPgetRowLinear, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPupgradeConsLinear(scip, cons, upgdcons) + ccall((:SCIPupgradeConsLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, upgdcons) +end + +function SCIPclassifyConstraintTypesLinear(scip, linconsstats) + ccall((:SCIPclassifyConstraintTypesLinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_LINCONSSTATS}), scip, linconsstats) +end diff --git a/src/wrapper/cons_linking.jl b/src/wrapper/cons_linking.jl new file mode 100644 index 00000000..e817e68d --- /dev/null +++ b/src/wrapper/cons_linking.jl @@ -0,0 +1,39 @@ +# Julia wrapper for header: /usr/include/scip/cons_linking.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrLinking(scip) + ccall((:SCIPincludeConshdlrLinking, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsLinking(scip, cons, name, intvar, binvars, vals, nbinvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsLinking, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, intvar, binvars, vals, nbinvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicLinking(scip, cons, name, intvar, binvars, vals, nbinvars) + ccall((:SCIPcreateConsBasicLinking, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), scip, cons, name, intvar, binvars, vals, nbinvars) +end + +function SCIPexistsConsLinking(scip, intvar) + ccall((:SCIPexistsConsLinking, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, intvar) +end + +function SCIPgetConsLinking(scip, intvar) + ccall((:SCIPgetConsLinking, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, intvar) +end + +function SCIPgetIntvarLinking(scip, cons) + ccall((:SCIPgetIntvarLinking, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetBinvarsLinking(scip, cons, binvars, nbinvars) + ccall((:SCIPgetBinvarsLinking, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}), scip, cons, binvars, nbinvars) +end + +function SCIPgetNBinvarsLinking(scip, cons) + ccall((:SCIPgetNBinvarsLinking, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetValsLinking(scip, cons) + ccall((:SCIPgetValsLinking, libscip), Ptr{Cint}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_logicor.jl b/src/wrapper/cons_logicor.jl new file mode 100644 index 00000000..e5f2c9af --- /dev/null +++ b/src/wrapper/cons_logicor.jl @@ -0,0 +1,39 @@ +# Julia wrapper for header: /usr/include/scip/cons_logicor.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrLogicor(scip) + ccall((:SCIPincludeConshdlrLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsLogicor(scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicLogicor(scip, cons, name, nvars, vars) + ccall((:SCIPcreateConsBasicLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, nvars, vars) +end + +function SCIPaddCoefLogicor(scip, cons, var) + ccall((:SCIPaddCoefLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, var) +end + +function SCIPgetNVarsLogicor(scip, cons) + ccall((:SCIPgetNVarsLogicor, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsLogicor(scip, cons) + ccall((:SCIPgetVarsLogicor, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualsolLogicor(scip, cons) + ccall((:SCIPgetDualsolLogicor, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualfarkasLogicor(scip, cons) + ccall((:SCIPgetDualfarkasLogicor, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRowLogicor(scip, cons) + ccall((:SCIPgetRowLogicor, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_nonlinear.jl b/src/wrapper/cons_nonlinear.jl new file mode 100644 index 00000000..d1fbd755 --- /dev/null +++ b/src/wrapper/cons_nonlinear.jl @@ -0,0 +1,111 @@ +# Julia wrapper for header: /usr/include/scip/cons_nonlinear.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrNonlinear(scip) + ccall((:SCIPincludeConshdlrNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPincludeNonlinconsUpgrade(scip, nonlinconsupgd, nodereform, priority, active, conshdlrname) + ccall((:SCIPincludeNonlinconsUpgrade, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, UInt32, Cstring), scip, nonlinconsupgd, nodereform, priority, active, conshdlrname) +end + +function SCIPcreateConsNonlinear(scip, cons, name, nlinvars, linvars, lincoefs, nexprtrees, exprtrees, nonlincoefs, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_EXPRTREE}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nlinvars, linvars, lincoefs, nexprtrees, exprtrees, nonlincoefs, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicNonlinear(scip, cons, name, nlinvars, linvars, lincoefs, nexprtrees, exprtrees, nonlincoefs, lhs, rhs) + ccall((:SCIPcreateConsBasicNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_EXPRTREE}}, Ptr{Cdouble}, Cdouble, Cdouble), scip, cons, name, nlinvars, linvars, lincoefs, nexprtrees, exprtrees, nonlincoefs, lhs, rhs) +end + +function SCIPcreateConsNonlinear2(scip, cons, name, nlinvars, linvars, lincoefs, exprgraphnode, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsNonlinear2, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_EXPRGRAPHNODE}, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nlinvars, linvars, lincoefs, exprgraphnode, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicNonlinear2(scip, cons, name, nlinvars, linvars, lincoefs, exprgraphnode, lhs, rhs) + ccall((:SCIPcreateConsBasicNonlinear2, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_EXPRGRAPHNODE}, Cdouble, Cdouble), scip, cons, name, nlinvars, linvars, lincoefs, exprgraphnode, lhs, rhs) +end + +function SCIPaddLinearVarNonlinear(scip, cons, var, coef) + ccall((:SCIPaddLinearVarNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, coef) +end + +function SCIPsetExprtreesNonlinear(scip, cons, nexprtrees, exprtrees, coefs) + ccall((:SCIPsetExprtreesNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cint, Ptr{Ptr{SCIP_EXPRTREE}}, Ptr{Cdouble}), scip, cons, nexprtrees, exprtrees, coefs) +end + +function SCIPaddExprtreesNonlinear(scip, cons, nexprtrees, exprtrees, coefs) + ccall((:SCIPaddExprtreesNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cint, Ptr{Ptr{SCIP_EXPRTREE}}, Ptr{Cdouble}), scip, cons, nexprtrees, exprtrees, coefs) +end + +function SCIPgetNlRowNonlinear(scip, cons, nlrow) + ccall((:SCIPgetNlRowNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_NLROW}}), scip, cons, nlrow) +end + +function SCIPgetNLinearVarsNonlinear(scip, cons) + ccall((:SCIPgetNLinearVarsNonlinear, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinearVarsNonlinear(scip, cons) + ccall((:SCIPgetLinearVarsNonlinear, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinearCoefsNonlinear(scip, cons) + ccall((:SCIPgetLinearCoefsNonlinear, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetNExprtreesNonlinear(scip, cons) + ccall((:SCIPgetNExprtreesNonlinear, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetExprtreesNonlinear(scip, cons) + ccall((:SCIPgetExprtreesNonlinear, libscip), Ptr{Ptr{SCIP_EXPRTREE}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetExprtreeCoefsNonlinear(scip, cons) + ccall((:SCIPgetExprtreeCoefsNonlinear, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetExprgraphNodeNonlinear(scip, cons) + ccall((:SCIPgetExprgraphNodeNonlinear, libscip), Ptr{SCIP_EXPRGRAPHNODE}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLhsNonlinear(scip, cons) + ccall((:SCIPgetLhsNonlinear, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsNonlinear(scip, cons) + ccall((:SCIPgetRhsNonlinear, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPcheckCurvatureNonlinear(scip, cons) + ccall((:SCIPcheckCurvatureNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetCurvatureNonlinear(scip, cons, checkcurv, curvature) + ccall((:SCIPgetCurvatureNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32, Ptr{SCIP_EXPRCURV}), scip, cons, checkcurv, curvature) +end + +function SCIPgetExprtreeCurvaturesNonlinear(scip, cons, checkcurv, curvatures) + ccall((:SCIPgetExprtreeCurvaturesNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32, Ptr{Ptr{SCIP_EXPRCURV}}), scip, cons, checkcurv, curvatures) +end + +function SCIPgetViolationNonlinear(scip, cons, sol, violation) + ccall((:SCIPgetViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, violation) +end + +function SCIPgetLinvarMayDecreaseNonlinear(scip, cons) + ccall((:SCIPgetLinvarMayDecreaseNonlinear, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinvarMayIncreaseNonlinear(scip, cons) + ccall((:SCIPgetLinvarMayIncreaseNonlinear, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetExprgraphNonlinear(scip, conshdlr) + ccall((:SCIPgetExprgraphNonlinear, libscip), Ptr{SCIP_EXPRGRAPH}, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}), scip, conshdlr) +end + +function SCIPcomputeHyperplaneThreePoints(scip, a1, a2, a3, b1, b2, b3, c1, c2, c3, alpha, beta, gamma_, delta) + ccall((:SCIPcomputeHyperplaneThreePoints, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), scip, a1, a2, a3, b1, b2, b3, c1, c2, c3, alpha, beta, gamma_, delta) +end diff --git a/src/wrapper/cons_or.jl b/src/wrapper/cons_or.jl new file mode 100644 index 00000000..cc01f571 --- /dev/null +++ b/src/wrapper/cons_or.jl @@ -0,0 +1,27 @@ +# Julia wrapper for header: /usr/include/scip/cons_or.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrOr(scip) + ccall((:SCIPincludeConshdlrOr, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsOr(scip, cons, name, resvar, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsOr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, resvar, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicOr(scip, cons, name, resvar, nvars, vars) + ccall((:SCIPcreateConsBasicOr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, resvar, nvars, vars) +end + +function SCIPgetNVarsOr(scip, cons) + ccall((:SCIPgetNVarsOr, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsOr(scip, cons) + ccall((:SCIPgetVarsOr, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetResultantOr(scip, cons) + ccall((:SCIPgetResultantOr, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_orbisack.jl b/src/wrapper/cons_orbisack.jl new file mode 100644 index 00000000..1a5f9968 --- /dev/null +++ b/src/wrapper/cons_orbisack.jl @@ -0,0 +1,23 @@ +# Julia wrapper for header: /usr/include/scip/cons_orbisack.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrOrbisack(scip) + ccall((:SCIPincludeConshdlrOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPseparateCoversOrbisack(scip, cons, sol, vars1, vars2, nrows, infeasible, ngen) + ccall((:SCIPseparateCoversOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{UInt32}, Ptr{Cint}), scip, cons, sol, vars1, vars2, nrows, infeasible, ngen) +end + +function SCIPcheckSolutionOrbisack(scip, sol, vars1, vars2, nrows, printreason, feasible) + ccall((:SCIPcheckSolutionOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, Ptr{UInt32}), scip, sol, vars1, vars2, nrows, printreason, feasible) +end + +function SCIPcreateConsOrbisack(scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicOrbisack(scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype) + ccall((:SCIPcreateConsBasicOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt32), scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype) +end diff --git a/src/wrapper/cons_orbitope.jl b/src/wrapper/cons_orbitope.jl new file mode 100644 index 00000000..41a0ab3f --- /dev/null +++ b/src/wrapper/cons_orbitope.jl @@ -0,0 +1,15 @@ +# Julia wrapper for header: /usr/include/scip/cons_orbitope.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrOrbitope(scip) + ccall((:SCIPincludeConshdlrOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsOrbitope(scip, cons, name, vars, orbitopetype, nspcons, nblocks, resolveprop, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Ptr{Ptr{SCIP_VAR}}}, SCIP_ORBITOPETYPE, Cint, Cint, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, vars, orbitopetype, nspcons, nblocks, resolveprop, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicOrbitope(scip, cons, name, vars, orbitopetype, nspcons, nblocks, resolveprop) + ccall((:SCIPcreateConsBasicOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Ptr{Ptr{SCIP_VAR}}}, SCIP_ORBITOPETYPE, Cint, Cint, UInt32), scip, cons, name, vars, orbitopetype, nspcons, nblocks, resolveprop) +end diff --git a/src/wrapper/cons_pseudoboolean.jl b/src/wrapper/cons_pseudoboolean.jl new file mode 100644 index 00000000..9189979d --- /dev/null +++ b/src/wrapper/cons_pseudoboolean.jl @@ -0,0 +1,71 @@ +# Julia wrapper for header: /usr/include/scip/cons_pseudoboolean.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrPseudoboolean(scip) + ccall((:SCIPincludeConshdlrPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsPseudobooleanWithConss(scip, cons, name, lincons, linconstype, andconss, andcoefs, nandconss, indvar, weight, issoftcons, intvar, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsPseudobooleanWithConss, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_CONS}, SCIP_LINEARCONSTYPE, Ptr{Ptr{SCIP_CONS}}, Ptr{Cdouble}, Cint, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{SCIP_VAR}, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, lincons, linconstype, andconss, andcoefs, nandconss, indvar, weight, issoftcons, intvar, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsPseudoboolean(scip, cons, name, linvars, nlinvars, linvals, terms, nterms, ntermvars, termvals, indvar, weight, issoftcons, intvar, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cdouble}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{SCIP_VAR}, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, linvars, nlinvars, linvals, terms, nterms, ntermvars, termvals, indvar, weight, issoftcons, intvar, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicPseudoboolean(scip, cons, name, linvars, nlinvars, linvals, terms, nterms, ntermvars, termvals, indvar, weight, issoftcons, intvar, lhs, rhs) + ccall((:SCIPcreateConsBasicPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cdouble}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, cons, name, linvars, nlinvars, linvals, terms, nterms, ntermvars, termvals, indvar, weight, issoftcons, intvar, lhs, rhs) +end + +function SCIPaddCoefPseudoboolean(scip, cons, var, val) + ccall((:SCIPaddCoefPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, val) +end + +function SCIPaddTermPseudoboolean(scip, cons, vars, nvars, val) + ccall((:SCIPaddTermPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Cint, Cdouble), scip, cons, vars, nvars, val) +end + +function SCIPgetIndVarPseudoboolean(scip, cons) + ccall((:SCIPgetIndVarPseudoboolean, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinearConsPseudoboolean(scip, cons) + ccall((:SCIPgetLinearConsPseudoboolean, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinearConsTypePseudoboolean(scip, cons) + ccall((:SCIPgetLinearConsTypePseudoboolean, libscip), SCIP_LINEARCONSTYPE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetNLinVarsWithoutAndPseudoboolean(scip, cons) + ccall((:SCIPgetNLinVarsWithoutAndPseudoboolean, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinDatasWithoutAndPseudoboolean(scip, cons, linvars, lincoefs, nlinvars) + ccall((:SCIPgetLinDatasWithoutAndPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}), scip, cons, linvars, lincoefs, nlinvars) +end + +function SCIPgetAndDatasPseudoboolean(scip, cons, andconss, andcoefs, nandconss) + ccall((:SCIPgetAndDatasPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cdouble}, Ptr{Cint}), scip, cons, andconss, andcoefs, nandconss) +end + +function SCIPgetNAndsPseudoboolean(scip, cons) + ccall((:SCIPgetNAndsPseudoboolean, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPchgLhsPseudoboolean(scip, cons, lhs) + ccall((:SCIPchgLhsPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, lhs) +end + +function SCIPchgRhsPseudoboolean(scip, cons, rhs) + ccall((:SCIPchgRhsPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, rhs) +end + +function SCIPgetLhsPseudoboolean(scip, cons) + ccall((:SCIPgetLhsPseudoboolean, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsPseudoboolean(scip, cons) + ccall((:SCIPgetRhsPseudoboolean, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_quadratic.jl b/src/wrapper/cons_quadratic.jl new file mode 100644 index 00000000..93651b71 --- /dev/null +++ b/src/wrapper/cons_quadratic.jl @@ -0,0 +1,171 @@ +# Julia wrapper for header: /usr/include/scip/cons_quadratic.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrQuadratic(scip) + ccall((:SCIPincludeConshdlrQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPincludeQuadconsUpgrade(scip, quadconsupgd, priority, active, conshdlrname) + ccall((:SCIPincludeQuadconsUpgrade, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}, Cint, UInt32, Cstring), scip, quadconsupgd, priority, active, conshdlrname) +end + +function SCIPcreateConsQuadratic(scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoeffs, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) + ccall((:SCIPcreateConsQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoeffs, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) +end + +function SCIPcreateConsBasicQuadratic(scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs) + ccall((:SCIPcreateConsBasicQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble), scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs) +end + +function SCIPcreateConsQuadratic2(scip, cons, name, nlinvars, linvars, lincoefs, nquadvarterms, quadvarterms, nbilinterms, bilinterms, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) + ccall((:SCIPcreateConsQuadratic2, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{SCIP_QUADVARTERM}, Cint, Ptr{SCIP_BILINTERM}, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nlinvars, linvars, lincoefs, nquadvarterms, quadvarterms, nbilinterms, bilinterms, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) +end + +function SCIPcreateConsBasicQuadratic2(scip, cons, name, nlinvars, linvars, lincoefs, nquadvarterms, quadvarterms, nbilinterms, bilinterms, lhs, rhs) + ccall((:SCIPcreateConsBasicQuadratic2, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{SCIP_QUADVARTERM}, Cint, Ptr{SCIP_BILINTERM}, Cdouble, Cdouble), scip, cons, name, nlinvars, linvars, lincoefs, nquadvarterms, quadvarterms, nbilinterms, bilinterms, lhs, rhs) +end + +function SCIPaddConstantQuadratic(scip, cons, constant) + ccall((:SCIPaddConstantQuadratic, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, constant) +end + +function SCIPaddLinearVarQuadratic(scip, cons, var, coef) + ccall((:SCIPaddLinearVarQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, coef) +end + +function SCIPaddQuadVarQuadratic(scip, cons, var, lincoef, sqrcoef) + ccall((:SCIPaddQuadVarQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, cons, var, lincoef, sqrcoef) +end + +function SCIPaddQuadVarLinearCoefQuadratic(scip, cons, var, coef) + ccall((:SCIPaddQuadVarLinearCoefQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, coef) +end + +function SCIPaddSquareCoefQuadratic(scip, cons, var, coef) + ccall((:SCIPaddSquareCoefQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, coef) +end + +function SCIPaddBilinTermQuadratic(scip, cons, var1, var2, coef) + ccall((:SCIPaddBilinTermQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var1, var2, coef) +end + +function SCIPgetNlRowQuadratic(scip, cons, nlrow) + ccall((:SCIPgetNlRowQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_NLROW}}), scip, cons, nlrow) +end + +function SCIPgetNLinearVarsQuadratic(scip, cons) + ccall((:SCIPgetNLinearVarsQuadratic, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinearVarsQuadratic(scip, cons) + ccall((:SCIPgetLinearVarsQuadratic, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetCoefsLinearVarsQuadratic(scip, cons) + ccall((:SCIPgetCoefsLinearVarsQuadratic, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetNQuadVarTermsQuadratic(scip, cons) + ccall((:SCIPgetNQuadVarTermsQuadratic, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetQuadVarTermsQuadratic(scip, cons) + ccall((:SCIPgetQuadVarTermsQuadratic, libscip), Ptr{SCIP_QUADVARTERM}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPsortQuadVarTermsQuadratic(scip, cons) + ccall((:SCIPsortQuadVarTermsQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPfindQuadVarTermQuadratic(scip, cons, var, pos) + ccall((:SCIPfindQuadVarTermQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{Cint}), scip, cons, var, pos) +end + +function SCIPgetNBilinTermsQuadratic(scip, cons) + ccall((:SCIPgetNBilinTermsQuadratic, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetBilinTermsQuadratic(scip, cons) + ccall((:SCIPgetBilinTermsQuadratic, libscip), Ptr{SCIP_BILINTERM}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLhsQuadratic(scip, cons) + ccall((:SCIPgetLhsQuadratic, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsQuadratic(scip, cons) + ccall((:SCIPgetRhsQuadratic, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinvarMayDecreaseQuadratic(scip, cons) + ccall((:SCIPgetLinvarMayDecreaseQuadratic, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLinvarMayIncreaseQuadratic(scip, cons) + ccall((:SCIPgetLinvarMayIncreaseQuadratic, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPcheckCurvatureQuadratic(scip, cons) + ccall((:SCIPcheckCurvatureQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPisConvexQuadratic(scip, cons) + ccall((:SCIPisConvexQuadratic, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPisConcaveQuadratic(scip, cons) + ccall((:SCIPisConcaveQuadratic, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetViolationQuadratic(scip, cons, sol, violation) + ccall((:SCIPgetViolationQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, violation) +end + +function SCIPisLinearLocalQuadratic(scip, cons) + ccall((:SCIPisLinearLocalQuadratic, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPaddToNlpiProblemQuadratic(scip, cons, nlpi, nlpiprob, scipvar2nlpivar, names) + ccall((:SCIPaddToNlpiProblemQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, UInt32), scip, cons, nlpi, nlpiprob, scipvar2nlpivar, names) +end + +function SCIPchgLhsQuadratic(scip, cons, lhs) + ccall((:SCIPchgLhsQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, lhs) +end + +function SCIPchgRhsQuadratic(scip, cons, rhs) + ccall((:SCIPchgRhsQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, rhs) +end + +function SCIPgetFeasibilityQuadratic(scip, cons, sol, feasibility) + ccall((:SCIPgetFeasibilityQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, feasibility) +end + +function SCIPgetActivityQuadratic(scip, cons, sol, activity) + ccall((:SCIPgetActivityQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, activity) +end + +function SCIPchgLinearCoefQuadratic(scip, cons, var, coef) + ccall((:SCIPchgLinearCoefQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, coef) +end + +function SCIPchgSquareCoefQuadratic(scip, cons, var, coef) + ccall((:SCIPchgSquareCoefQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, coef) +end + +function SCIPchgBilinCoefQuadratic(scip, cons, var1, var2, coef) + ccall((:SCIPchgBilinCoefQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var1, var2, coef) +end + +function SCIPgetNAllBilinearTermsQuadratic(scip) + ccall((:SCIPgetNAllBilinearTermsQuadratic, libscip), Cint, (Ptr{SCIP_},), scip) +end + +function SCIPgetAllBilinearTermsQuadratic(scip, x, y, nbilinterms, nunderests, noverests, maxnonconvexity) + ccall((:SCIPgetAllBilinearTermsQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), scip, x, y, nbilinterms, nunderests, noverests, maxnonconvexity) +end + +function SCIPaddBilinearIneqQuadratic(scip, x, y, idx, xcoef, ycoef, constant, success) + ccall((:SCIPaddBilinearIneqQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cint, Cdouble, Cdouble, Cdouble, Ptr{UInt32}), scip, x, y, idx, xcoef, ycoef, constant, success) +end diff --git a/src/wrapper/cons_setppc.jl b/src/wrapper/cons_setppc.jl new file mode 100644 index 00000000..0682d03a --- /dev/null +++ b/src/wrapper/cons_setppc.jl @@ -0,0 +1,67 @@ +# Julia wrapper for header: /usr/include/scip/cons_setppc.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrSetppc(scip) + ccall((:SCIPincludeConshdlrSetppc, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsSetpart(scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsSetpart, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicSetpart(scip, cons, name, nvars, vars) + ccall((:SCIPcreateConsBasicSetpart, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, nvars, vars) +end + +function SCIPcreateConsSetpack(scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsSetpack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicSetpack(scip, cons, name, nvars, vars) + ccall((:SCIPcreateConsBasicSetpack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, nvars, vars) +end + +function SCIPcreateConsSetcover(scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsSetcover, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicSetcover(scip, cons, name, nvars, vars) + ccall((:SCIPcreateConsBasicSetcover, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, nvars, vars) +end + +function SCIPaddCoefSetppc(scip, cons, var) + ccall((:SCIPaddCoefSetppc, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, var) +end + +function SCIPgetNVarsSetppc(scip, cons) + ccall((:SCIPgetNVarsSetppc, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsSetppc(scip, cons) + ccall((:SCIPgetVarsSetppc, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetTypeSetppc(scip, cons) + ccall((:SCIPgetTypeSetppc, libscip), SCIP_SETPPCTYPE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualsolSetppc(scip, cons) + ccall((:SCIPgetDualsolSetppc, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualfarkasSetppc(scip, cons) + ccall((:SCIPgetDualfarkasSetppc, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRowSetppc(scip, cons) + ccall((:SCIPgetRowSetppc, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetNFixedonesSetppc(scip, cons) + ccall((:SCIPgetNFixedonesSetppc, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetNFixedzerosSetppc(scip, cons) + ccall((:SCIPgetNFixedzerosSetppc, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_soc.jl b/src/wrapper/cons_soc.jl new file mode 100644 index 00000000..914dad66 --- /dev/null +++ b/src/wrapper/cons_soc.jl @@ -0,0 +1,55 @@ +# Julia wrapper for header: /usr/include/scip/cons_soc.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrSOC(scip) + ccall((:SCIPincludeConshdlrSOC, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsSOC(scip, cons, name, nvars, vars, coefs, offsets, constant, rhsvar, rhscoeff, rhsoffset, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) + ccall((:SCIPcreateConsSOC, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Ptr{SCIP_VAR}, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, coefs, offsets, constant, rhsvar, rhscoeff, rhsoffset, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) +end + +function SCIPcreateConsBasicSOC(scip, cons, name, nvars, vars, coefs, offsets, constant, rhsvar, rhscoeff, rhsoffset) + ccall((:SCIPcreateConsBasicSOC, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, cons, name, nvars, vars, coefs, offsets, constant, rhsvar, rhscoeff, rhsoffset) +end + +function SCIPgetNlRowSOC(scip, cons, nlrow) + ccall((:SCIPgetNlRowSOC, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_NLROW}}), scip, cons, nlrow) +end + +function SCIPgetNLhsVarsSOC(scip, cons) + ccall((:SCIPgetNLhsVarsSOC, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLhsVarsSOC(scip, cons) + ccall((:SCIPgetLhsVarsSOC, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLhsCoefsSOC(scip, cons) + ccall((:SCIPgetLhsCoefsSOC, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLhsOffsetsSOC(scip, cons) + ccall((:SCIPgetLhsOffsetsSOC, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLhsConstantSOC(scip, cons) + ccall((:SCIPgetLhsConstantSOC, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsVarSOC(scip, cons) + ccall((:SCIPgetRhsVarSOC, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsCoefSOC(scip, cons) + ccall((:SCIPgetRhsCoefSOC, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsOffsetSOC(scip, cons) + ccall((:SCIPgetRhsOffsetSOC, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPaddToNlpiProblemSOC(scip, cons, nlpi, nlpiprob, scipvar2nlpivar, names) + ccall((:SCIPaddToNlpiProblemSOC, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, UInt32), scip, cons, nlpi, nlpiprob, scipvar2nlpivar, names) +end diff --git a/src/wrapper/cons_sos1.jl b/src/wrapper/cons_sos1.jl new file mode 100644 index 00000000..740b2a87 --- /dev/null +++ b/src/wrapper/cons_sos1.jl @@ -0,0 +1,59 @@ +# Julia wrapper for header: /usr/include/scip/cons_sos1.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrSOS1(scip) + ccall((:SCIPincludeConshdlrSOS1, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsSOS1(scip, cons, name, nvars, vars, weights, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsSOS1, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, weights, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicSOS1(scip, cons, name, nvars, vars, weights) + ccall((:SCIPcreateConsBasicSOS1, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, name, nvars, vars, weights) +end + +function SCIPaddVarSOS1(scip, cons, var, weight) + ccall((:SCIPaddVarSOS1, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, weight) +end + +function SCIPappendVarSOS1(scip, cons, var) + ccall((:SCIPappendVarSOS1, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, var) +end + +function SCIPgetNVarsSOS1(scip, cons) + ccall((:SCIPgetNVarsSOS1, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsSOS1(scip, cons) + ccall((:SCIPgetVarsSOS1, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetWeightsSOS1(scip, cons) + ccall((:SCIPgetWeightsSOS1, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetConflictgraphSOS1(conshdlr) + ccall((:SCIPgetConflictgraphSOS1, libscip), Ptr{SCIP_DIGRAPH}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPgetNSOS1Vars(conshdlr) + ccall((:SCIPgetNSOS1Vars, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPvarIsSOS1(conshdlr, var) + ccall((:SCIPvarIsSOS1, libscip), UInt32, (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}), conshdlr, var) +end + +function SCIPvarGetNodeSOS1(conshdlr, var) + ccall((:SCIPvarGetNodeSOS1, libscip), Cint, (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}), conshdlr, var) +end + +function SCIPnodeGetVarSOS1(conflictgraph, node) + ccall((:SCIPnodeGetVarSOS1, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_DIGRAPH}, Cint), conflictgraph, node) +end + +function SCIPmakeSOS1sFeasible(scip, conshdlr, sol, changed, success) + ccall((:SCIPmakeSOS1sFeasible, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_SOL}, Ptr{UInt32}, Ptr{UInt32}), scip, conshdlr, sol, changed, success) +end diff --git a/src/wrapper/cons_sos2.jl b/src/wrapper/cons_sos2.jl new file mode 100644 index 00000000..df593846 --- /dev/null +++ b/src/wrapper/cons_sos2.jl @@ -0,0 +1,35 @@ +# Julia wrapper for header: /usr/include/scip/cons_sos2.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrSOS2(scip) + ccall((:SCIPincludeConshdlrSOS2, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsSOS2(scip, cons, name, nvars, vars, weights, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsSOS2, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, nvars, vars, weights, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicSOS2(scip, cons, name, nvars, vars, weights) + ccall((:SCIPcreateConsBasicSOS2, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, name, nvars, vars, weights) +end + +function SCIPaddVarSOS2(scip, cons, var, weight) + ccall((:SCIPaddVarSOS2, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, weight) +end + +function SCIPappendVarSOS2(scip, cons, var) + ccall((:SCIPappendVarSOS2, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, var) +end + +function SCIPgetNVarsSOS2(scip, cons) + ccall((:SCIPgetNVarsSOS2, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsSOS2(scip, cons) + ccall((:SCIPgetVarsSOS2, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetWeightsSOS2(scip, cons) + ccall((:SCIPgetWeightsSOS2, libscip), Ptr{Cdouble}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_superindicator.jl b/src/wrapper/cons_superindicator.jl new file mode 100644 index 00000000..7e9033d3 --- /dev/null +++ b/src/wrapper/cons_superindicator.jl @@ -0,0 +1,31 @@ +# Julia wrapper for header: /usr/include/scip/cons_superindicator.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrSuperindicator(scip) + ccall((:SCIPincludeConshdlrSuperindicator, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsSuperindicator(scip, cons, name, binvar, slackcons, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsSuperindicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, binvar, slackcons, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicSuperindicator(scip, cons, name, binvar, slackcons) + ccall((:SCIPcreateConsBasicSuperindicator, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}), scip, cons, name, binvar, slackcons) +end + +function SCIPgetBinaryVarSuperindicator(cons) + ccall((:SCIPgetBinaryVarSuperindicator, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_CONS},), cons) +end + +function SCIPgetSlackConsSuperindicator(cons) + ccall((:SCIPgetSlackConsSuperindicator, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_CONS},), cons) +end + +function SCIPtransformMinUC(scip, success) + ccall((:SCIPtransformMinUC, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{UInt32}), scip, success) +end + +function SCIPdialogExecChangeMinUC(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecChangeMinUC, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end diff --git a/src/wrapper/cons_symresack.jl b/src/wrapper/cons_symresack.jl new file mode 100644 index 00000000..89727622 --- /dev/null +++ b/src/wrapper/cons_symresack.jl @@ -0,0 +1,19 @@ +# Julia wrapper for header: /usr/include/scip/cons_symresack.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrSymresack(scip) + ccall((:SCIPincludeConshdlrSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateSymbreakCons(scip, cons, name, perm, vars, nvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateSymbreakCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, perm, vars, nvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsSymresack(scip, cons, name, perm, vars, nvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, perm, vars, nvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicSymresack(scip, cons, name, perm, vars, nvars) + ccall((:SCIPcreateConsBasicSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, cons, name, perm, vars, nvars) +end diff --git a/src/wrapper/cons_varbound.jl b/src/wrapper/cons_varbound.jl new file mode 100644 index 00000000..ceac180e --- /dev/null +++ b/src/wrapper/cons_varbound.jl @@ -0,0 +1,47 @@ +# Julia wrapper for header: /usr/include/scip/cons_varbound.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrVarbound(scip) + ccall((:SCIPincludeConshdlrVarbound, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsVarbound(scip, cons, name, var, vbdvar, vbdcoef, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsVarbound, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, var, vbdvar, vbdcoef, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicVarbound(scip, cons, name, var, vbdvar, vbdcoef, lhs, rhs) + ccall((:SCIPcreateConsBasicVarbound, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, cons, name, var, vbdvar, vbdcoef, lhs, rhs) +end + +function SCIPgetLhsVarbound(scip, cons) + ccall((:SCIPgetLhsVarbound, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsVarbound(scip, cons) + ccall((:SCIPgetRhsVarbound, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarVarbound(scip, cons) + ccall((:SCIPgetVarVarbound, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVbdvarVarbound(scip, cons) + ccall((:SCIPgetVbdvarVarbound, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVbdcoefVarbound(scip, cons) + ccall((:SCIPgetVbdcoefVarbound, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualsolVarbound(scip, cons) + ccall((:SCIPgetDualsolVarbound, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetDualfarkasVarbound(scip, cons) + ccall((:SCIPgetDualfarkasVarbound, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRowVarbound(scip, cons) + ccall((:SCIPgetRowVarbound, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/cons_xor.jl b/src/wrapper/cons_xor.jl new file mode 100644 index 00000000..beebd9a8 --- /dev/null +++ b/src/wrapper/cons_xor.jl @@ -0,0 +1,31 @@ +# Julia wrapper for header: /usr/include/scip/cons_xor.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeConshdlrXor(scip) + ccall((:SCIPincludeConshdlrXor, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end + +function SCIPcreateConsXor(scip, cons, name, rhs, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsXor, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, UInt32, Cint, Ptr{Ptr{SCIP_VAR}}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, rhs, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicXor(scip, cons, name, rhs, nvars, vars) + ccall((:SCIPcreateConsBasicXor, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, UInt32, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, rhs, nvars, vars) +end + +function SCIPgetNVarsXor(scip, cons) + ccall((:SCIPgetNVarsXor, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetVarsXor(scip, cons) + ccall((:SCIPgetVarsXor, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetIntVarXor(scip, cons) + ccall((:SCIPgetIntVarXor, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetRhsXor(scip, cons) + ccall((:SCIPgetRhsXor, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end