generate_wrapper: include all cons_* headers

- otherwise, constraints can not be created!
scipopt · Dec 17, 2018 · e7401cf · e7401cf
1 parent 94749bc
commit e7401cf
Show file tree

Hide file tree

Showing 35 changed files with 1,601 additions and 1 deletion.
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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