From 158beb4087fd70c081aefdbba324d50474bfc6a2 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 14 Dec 2018 21:27:55 +0100 Subject: [PATCH 01/82] add gen/generate_wrapper.jl - based on example of ArrowGlib.jl - incomplete (only wrap scip_general.h) --- gen/generate_wrapper.jl | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 gen/generate_wrapper.jl diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl new file mode 100644 index 00000000..344609c5 --- /dev/null +++ b/gen/generate_wrapper.jl @@ -0,0 +1,24 @@ +using Clang + +header_path = "/usr/include/scip" +headers = [ + "scip_general.h", +] +clang_includes = [ + "/usr/lib/llvm-6.0/lib/clang/6.0.0/include", +] + +context = wrap_c.init( + # header files we want wrapped + headers=[joinpath(header_path, h) for h in headers], + # single output file + common_file="scip_wrapper.jl", + output_dir="../src", + clang_includes=clang_includes, + clang_diagnostics=true, + # do not wrap included headers + header_wrapped=(header, cursorname) -> header == cursorname, + header_library=header_name -> "libscip" +) + +run(context) From 39d47e91b7a2184512f4ac8e7555789614c21fa6 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 14 Dec 2018 22:10:05 +0100 Subject: [PATCH 02/82] add folder for generated wrapper files --- src/wrapper/README.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 src/wrapper/README.md diff --git a/src/wrapper/README.md b/src/wrapper/README.md new file mode 100644 index 00000000..040fc603 --- /dev/null +++ b/src/wrapper/README.md @@ -0,0 +1,2 @@ +These files are automatically generated with `Clang.jl`. See +`gen/generate_wrapper.jl` for details. From 7c3b6212a4a4bbe8e0c30362d1086d7aab5069c7 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 14 Dec 2018 22:43:47 +0100 Subject: [PATCH 03/82] wrap all scip_*.h files - these declarations used to be in scip.h - types are still missing --- gen/generate_wrapper.jl | 13 +- src/wrapper/commons.jl | 58 +++ src/wrapper/scip_bandit.jl | 19 + src/wrapper/scip_benders.jl | 175 ++++++++ src/wrapper/scip_branch.jl | 199 +++++++++ src/wrapper/scip_compr.jl | 51 +++ src/wrapper/scip_concurrent.jl | 31 ++ src/wrapper/scip_conflict.jl | 107 +++++ src/wrapper/scip_cons.jl | 319 ++++++++++++++ src/wrapper/scip_copy.jl | 107 +++++ src/wrapper/scip_cut.jl | 123 ++++++ src/wrapper/scip_datastructures.jl | 155 +++++++ src/wrapper/scip_debug.jl | 11 + src/wrapper/scip_dialog.jl | 43 ++ src/wrapper/scip_disp.jl | 27 ++ src/wrapper/scip_event.jl | 75 ++++ src/wrapper/scip_expr.jl | 19 + src/wrapper/scip_general.jl | 103 +++++ src/wrapper/scip_heur.jl | 55 +++ src/wrapper/scip_lp.jl | 367 ++++++++++++++++ src/wrapper/scip_mem.jl | 39 ++ src/wrapper/scip_message.jl | 23 + src/wrapper/scip_nlp.jl | 303 +++++++++++++ src/wrapper/scip_nodesel.jl | 59 +++ src/wrapper/scip_nonlinear.jl | 39 ++ src/wrapper/scip_numerics.jl | 347 +++++++++++++++ src/wrapper/scip_param.jl | 191 +++++++++ src/wrapper/scip_presol.jl | 51 +++ src/wrapper/scip_pricer.jl | 63 +++ src/wrapper/scip_prob.jl | 331 ++++++++++++++ src/wrapper/scip_probing.jl | 111 +++++ src/wrapper/scip_prop.jl | 71 +++ src/wrapper/scip_randnumgen.jl | 19 + src/wrapper/scip_reader.jl | 39 ++ src/wrapper/scip_relax.jl | 51 +++ src/wrapper/scip_reopt.jl | 79 ++++ src/wrapper/scip_sepa.jl | 55 +++ src/wrapper/scip_sol.jl | 291 +++++++++++++ src/wrapper/scip_solve.jl | 79 ++++ src/wrapper/scip_solvingstats.jl | 495 +++++++++++++++++++++ src/wrapper/scip_table.jl | 19 + src/wrapper/scip_timing.jl | 75 ++++ src/wrapper/scip_tree.jl | 119 ++++++ src/wrapper/scip_validation.jl | 7 + src/wrapper/scip_var.jl | 663 +++++++++++++++++++++++++++++ 45 files changed, 5670 insertions(+), 6 deletions(-) create mode 100644 src/wrapper/commons.jl create mode 100644 src/wrapper/scip_bandit.jl create mode 100644 src/wrapper/scip_benders.jl create mode 100644 src/wrapper/scip_branch.jl create mode 100644 src/wrapper/scip_compr.jl create mode 100644 src/wrapper/scip_concurrent.jl create mode 100644 src/wrapper/scip_conflict.jl create mode 100644 src/wrapper/scip_cons.jl create mode 100644 src/wrapper/scip_copy.jl create mode 100644 src/wrapper/scip_cut.jl create mode 100644 src/wrapper/scip_datastructures.jl create mode 100644 src/wrapper/scip_debug.jl create mode 100644 src/wrapper/scip_dialog.jl create mode 100644 src/wrapper/scip_disp.jl create mode 100644 src/wrapper/scip_event.jl create mode 100644 src/wrapper/scip_expr.jl create mode 100644 src/wrapper/scip_general.jl create mode 100644 src/wrapper/scip_heur.jl create mode 100644 src/wrapper/scip_lp.jl create mode 100644 src/wrapper/scip_mem.jl create mode 100644 src/wrapper/scip_message.jl create mode 100644 src/wrapper/scip_nlp.jl create mode 100644 src/wrapper/scip_nodesel.jl create mode 100644 src/wrapper/scip_nonlinear.jl create mode 100644 src/wrapper/scip_numerics.jl create mode 100644 src/wrapper/scip_param.jl create mode 100644 src/wrapper/scip_presol.jl create mode 100644 src/wrapper/scip_pricer.jl create mode 100644 src/wrapper/scip_prob.jl create mode 100644 src/wrapper/scip_probing.jl create mode 100644 src/wrapper/scip_prop.jl create mode 100644 src/wrapper/scip_randnumgen.jl create mode 100644 src/wrapper/scip_reader.jl create mode 100644 src/wrapper/scip_relax.jl create mode 100644 src/wrapper/scip_reopt.jl create mode 100644 src/wrapper/scip_sepa.jl create mode 100644 src/wrapper/scip_sol.jl create mode 100644 src/wrapper/scip_solve.jl create mode 100644 src/wrapper/scip_solvingstats.jl create mode 100644 src/wrapper/scip_table.jl create mode 100644 src/wrapper/scip_timing.jl create mode 100644 src/wrapper/scip_tree.jl create mode 100644 src/wrapper/scip_validation.jl create mode 100644 src/wrapper/scip_var.jl diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index 344609c5..d6cfa3ae 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -1,9 +1,11 @@ using Clang header_path = "/usr/include/scip" -headers = [ - "scip_general.h", -] +all_headers = readdir(header_path) + +headers = vcat( + filter(h -> startswith(h, "scip_"), all_headers), +) clang_includes = [ "/usr/lib/llvm-6.0/lib/clang/6.0.0/include", ] @@ -11,9 +13,8 @@ clang_includes = [ context = wrap_c.init( # header files we want wrapped headers=[joinpath(header_path, h) for h in headers], - # single output file - common_file="scip_wrapper.jl", - output_dir="../src", + common_file="commons.jl", + output_dir="../src/wrapper", clang_includes=clang_includes, clang_diagnostics=true, # do not wrap included headers diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl new file mode 100644 index 00000000..8f8d1a87 --- /dev/null +++ b/src/wrapper/commons.jl @@ -0,0 +1,58 @@ +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +# Skipping MacroDefinition: SCIPallocMemory ( scip , ptr ) ( ( BMSallocMemory ( ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocMemoryArray ( scip , ptr , num ) ( ( BMSallocMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocClearMemoryArray ( scip , ptr , num ) ( ( BMSallocClearMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocMemorySize ( scip , ptr , size ) ( ( BMSallocMemorySize ( ( ptr ) , ( size ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPreallocMemoryArray ( scip , ptr , newnum ) ( ( BMSreallocMemoryArray ( ( ptr ) , ( newnum ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPreallocMemorySize ( scip , ptr , newsize ) ( ( BMSreallocMemorySize ( ( ptr ) , ( newsize ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPduplicateMemory ( scip , ptr , source ) ( ( BMSduplicateMemory ( ( ptr ) , ( source ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPduplicateMemoryArray ( scip , ptr , source , num ) ( ( BMSduplicateMemoryArray ( ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPfreeMemory ( scip , ptr ) BMSfreeMemory ( ptr ) # +# Skipping MacroDefinition: SCIPfreeMemoryNull ( scip , ptr ) BMSfreeMemoryNull ( ptr ) # +# Skipping MacroDefinition: SCIPfreeMemoryArray ( scip , ptr ) BMSfreeMemoryArray ( ptr ) # +# Skipping MacroDefinition: SCIPfreeMemoryArrayNull ( scip , ptr ) BMSfreeMemoryArrayNull ( ptr ) # +# Skipping MacroDefinition: SCIPfreeMemorySize ( scip , ptr ) BMSfreeMemorySize ( ptr ) # +# Skipping MacroDefinition: SCIPfreeMemorySizeNull ( scip , ptr ) BMSfreeMemorySizeNull ( ptr ) /* Block Memory Management Macros +# * +# */ +# Skipping MacroDefinition: SCIPallocBlockMemory ( scip , ptr ) ( ( BMSallocBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocBlockMemoryArray ( scip , ptr , num ) ( ( BMSallocBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocBlockMemorySize ( scip , ptr , size ) ( ( BMSallocBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocClearBlockMemoryArray ( scip , ptr , num ) ( ( BMSallocClearBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPreallocBlockMemoryArray ( scip , ptr , oldnum , newnum ) ( ( BMSreallocBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( oldnum ) , ( newnum ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPreallocBlockMemorySize ( scip , ptr , oldsize , newsize ) ( ( BMSreallocBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( oldsize ) , ( newsize ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPduplicateBlockMemory ( scip , ptr , source ) ( ( BMSduplicateBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) , ( source ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPduplicateBlockMemoryArray ( scip , ptr , source , num ) ( ( BMSduplicateBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPensureBlockMemoryArray ( scip , ptr , arraysizeptr , minsize ) ( ( SCIPensureBlockMemoryArray_call ( ( scip ) , ( void * * ) ( ptr ) , sizeof ( * * ( ptr ) ) , ( arraysizeptr ) , ( minsize ) ) ) ) # +# Skipping MacroDefinition: SCIPfreeBlockMemory ( scip , ptr ) BMSfreeBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPfreeBlockMemoryNull ( scip , ptr ) BMSfreeBlockMemoryNull ( SCIPblkmem ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPfreeBlockMemoryArray ( scip , ptr , num ) BMSfreeBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) # +# Skipping MacroDefinition: SCIPfreeBlockMemoryArrayNull ( scip , ptr , num ) BMSfreeBlockMemoryArrayNull ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) # +# Skipping MacroDefinition: SCIPfreeBlockMemorySize ( scip , ptr , size ) BMSfreeBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) # +# Skipping MacroDefinition: SCIPfreeBlockMemorySizeNull ( scip , ptr , size ) BMSfreeBlockMemorySizeNull ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) /* Buffer Memory Management Macros +# * +# * +# */ +# Skipping MacroDefinition: SCIPallocBuffer ( scip , ptr ) ( ( BMSallocBufferMemory ( SCIPbuffer ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocBufferArray ( scip , ptr , num ) ( ( BMSallocBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocClearBufferArray ( scip , ptr , num ) ( ( BMSallocClearBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPreallocBufferArray ( scip , ptr , num ) ( ( BMSreallocBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPduplicateBuffer ( scip , ptr , source ) ( ( BMSduplicateBufferMemory ( SCIPbuffer ( scip ) , ( ptr ) , ( source ) , ( size_t ) sizeof ( * * ( ptr ) ) ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPduplicateBufferArray ( scip , ptr , source , num ) ( ( BMSduplicateBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPfreeBuffer ( scip , ptr ) BMSfreeBufferMemorySize ( SCIPbuffer ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPfreeBufferNull ( scip , ptr ) BMSfreeBufferMemoryNull ( SCIPbuffer ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPfreeBufferArray ( scip , ptr ) BMSfreeBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPfreeBufferArrayNull ( scip , ptr ) BMSfreeBufferMemoryArrayNull ( SCIPbuffer ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPallocCleanBuffer ( scip , ptr ) ( ( BMSallocBufferMemory ( SCIPcleanbuffer ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPallocCleanBufferArray ( scip , ptr , num ) ( ( BMSallocBufferMemoryArray ( SCIPcleanbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # +# Skipping MacroDefinition: SCIPfreeCleanBuffer ( scip , ptr ) BMSfreeBufferMemorySize ( SCIPcleanbuffer ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPfreeCleanBufferNull ( scip , ptr ) BMSfreeBufferMemoryNull ( SCIPcleanbuffer ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPfreeCleanBufferArray ( scip , ptr ) BMSfreeBufferMemoryArray ( SCIPcleanbuffer ( scip ) , ( ptr ) ) # +# Skipping MacroDefinition: SCIPfreeCleanBufferArrayNull ( scip , ptr ) BMSfreeBufferMemoryArrayNull ( SCIPcleanbuffer ( scip ) , ( ptr ) ) /* Memory Management Functions +# * +# * +# */ +# Skipping MacroDefinition: SCIPdebugMsg ( scip , ... ) while ( FALSE ) SCIPprintDebugMessage ( scip , __FILE__ , __LINE__ , __VA_ARGS__ ) # +# Skipping MacroDefinition: SCIPdebugMsgPrint ( scip , ... ) while ( FALSE ) SCIPdebugMessagePrint ( scip , __VA_ARGS__ ) # diff --git a/src/wrapper/scip_bandit.jl b/src/wrapper/scip_bandit.jl new file mode 100644 index 00000000..364df688 --- /dev/null +++ b/src/wrapper/scip_bandit.jl @@ -0,0 +1,19 @@ +# Julia wrapper for header: /usr/include/scip/scip_bandit.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeBanditvtable(scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) + ccall((:SCIPincludeBanditvtable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDITVTABLE}}, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) +end + +function SCIPfindBanditvtable(scip, name) + ccall((:SCIPfindBanditvtable, libscip), Ptr{SCIP_BANDITVTABLE}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPfreeBandit(scip, bandit) + ccall((:SCIPfreeBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}), scip, bandit) +end + +function SCIPresetBandit(scip, bandit, priorities, seed::UInt32) + ccall((:SCIPresetBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BANDIT}, Ptr{Cdouble}, UInt32), scip, bandit, priorities, seed) +end diff --git a/src/wrapper/scip_benders.jl b/src/wrapper/scip_benders.jl new file mode 100644 index 00000000..f34f43ed --- /dev/null +++ b/src/wrapper/scip_benders.jl @@ -0,0 +1,175 @@ +# Julia wrapper for header: /usr/include/scip/scip_benders.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeBenders(scip, name, desc, priority::Cint, cutlp::UInt32, cutpseudo::UInt32, cutrelax::UInt32, shareauxvars::UInt32, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre, bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex, benderssolvesub, benderspostsolve, bendersfreesub, bendersdata) + ccall((:SCIPincludeBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre, bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex, benderssolvesub, benderspostsolve, bendersfreesub, bendersdata) +end + +function SCIPincludeBendersBasic(scip, bendersptr, name, desc, priority::Cint, cutlp::UInt32, cutpseudo::UInt32, cutrelax::UInt32, shareauxvars::UInt32, bendersgetvar, benderscreatesub, bendersdata) + ccall((:SCIPincludeBendersBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BENDERS}}, Cstring, Cstring, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, bendersptr, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, bendersgetvar, benderscreatesub, bendersdata) +end + +function SCIPsetBendersCopy(scip, benders, benderscopy) + ccall((:SCIPsetBendersCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderscopy) +end + +function SCIPsetBendersFree(scip, benders, bendersfree) + ccall((:SCIPsetBendersFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersfree) +end + +function SCIPsetBendersInit(scip, benders, bendersinit) + ccall((:SCIPsetBendersInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinit) +end + +function SCIPsetBendersExit(scip, benders, bendersexit) + ccall((:SCIPsetBendersExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexit) +end + +function SCIPsetBendersInitpre(scip, benders, bendersinitpre) + ccall((:SCIPsetBendersInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitpre) +end + +function SCIPsetBendersExitpre(scip, benders, bendersexitpre) + ccall((:SCIPsetBendersExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitpre) +end + +function SCIPsetBendersInitsol(scip, benders, bendersinitsol) + ccall((:SCIPsetBendersInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitsol) +end + +function SCIPsetBendersExitsol(scip, benders, bendersexitsol) + ccall((:SCIPsetBendersExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitsol) +end + +function SCIPsetBendersPresubsolve(scip, benders, benderspresubsolve) + ccall((:SCIPsetBendersPresubsolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderspresubsolve) +end + +function SCIPsetBendersSolveAndFreesub(scip, benders, benderssolvesubconvex, benderssolvesub, bendersfreesub) + ccall((:SCIPsetBendersSolveAndFreesub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, benders, benderssolvesubconvex, benderssolvesub, bendersfreesub) +end + +function SCIPsetBendersPostsolve(scip, benders, benderspostsolve) + ccall((:SCIPsetBendersPostsolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderspostsolve) +end + +function SCIPfindBenders(scip, name) + ccall((:SCIPfindBenders, libscip), Ptr{SCIP_BENDERS}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetBenders(scip) + ccall((:SCIPgetBenders, libscip), Ptr{Ptr{SCIP_BENDERS}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNBenders(scip) + ccall((:SCIPgetNBenders, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNActiveBenders(scip) + ccall((:SCIPgetNActiveBenders, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPactivateBenders(scip, benders, nsubproblems::Cint) + ccall((:SCIPactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, nsubproblems) +end + +function SCIPdeactivateBenders(scip, benders) + ccall((:SCIPdeactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) +end + +function SCIPsetBendersPriority(scip, benders, priority::Cint) + ccall((:SCIPsetBendersPriority, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, priority) +end + +function SCIPsolveBendersSubproblems(scip, benders, sol, result, infeasible, auxviol, _type::SCIP_BENDERSENFOTYPE, checkint::UInt32) + ccall((:SCIPsolveBendersSubproblems, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}, Ptr{UInt32}, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32), scip, benders, sol, result, infeasible, auxviol, _type, checkint) +end + +function SCIPgetBendersMasterVar(scip, benders, var, mappedvar) + ccall((:SCIPgetBendersMasterVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, benders, var, mappedvar) +end + +function SCIPgetBendersSubproblemVar(scip, benders, var, mappedvar, probnumber::Cint) + ccall((:SCIPgetBendersSubproblemVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, benders, var, mappedvar, probnumber) +end + +function SCIPgetBendersNSubproblems(scip, benders) + ccall((:SCIPgetBendersNSubproblems, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) +end + +function SCIPaddBendersSubproblem(scip, benders, subproblem) + ccall((:SCIPaddBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP}), scip, benders, subproblem) +end + +function SCIPsetupBendersSubproblem(scip, benders, sol, probnumber::Cint) + ccall((:SCIPsetupBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) +end + +function SCIPsolveBendersSubproblem(scip, benders, sol, probnumber::Cint, infeasible, _type::SCIP_BENDERSENFOTYPE, solvecip::UInt32, objective) + ccall((:SCIPsolveBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32, Ptr{Cdouble}), scip, benders, sol, probnumber, infeasible, _type, solvecip, objective) +end + +function SCIPfreeBendersSubproblem(scip, benders, probnumber::Cint) + ccall((:SCIPfreeBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, probnumber) +end + +function SCIPcheckBendersSubproblemOptimality(scip, benders, sol, probnumber::Cint, optimal) + ccall((:SCIPcheckBendersSubproblemOptimality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}), scip, benders, sol, probnumber, optimal) +end + +function SCIPgetBendersAuxiliaryVarVal(scip, benders, sol, probnumber::Cint) + ccall((:SCIPgetBendersAuxiliaryVarVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) +end + +function SCIPcomputeBendersSubproblemLowerbound(scip, benders, probnumber::Cint, lowerbound, infeasible) + ccall((:SCIPcomputeBendersSubproblemLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{Cdouble}, Ptr{UInt32}), scip, benders, probnumber, lowerbound, infeasible) +end + +function SCIPmergeBendersSubproblemIntoMaster(scip, benders, varmap, consmap, probnumber::Cint) + ccall((:SCIPmergeBendersSubproblemIntoMaster, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cint), scip, benders, varmap, consmap, probnumber) +end + +function SCIPincludeBenderscut(scip, benders, name, desc, priority::Cint, islpcut::UInt32, benderscutcopy, benderscutfree, benderscutinit, benderscutexit, benderscutinitsol, benderscutexitsol, benderscutexec, benderscutdata) + ccall((:SCIPincludeBenderscut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, name, desc, priority, islpcut, benderscutcopy, benderscutfree, benderscutinit, benderscutexit, benderscutinitsol, benderscutexitsol, benderscutexec, benderscutdata) +end + +function SCIPincludeBenderscutBasic(scip, benders, benderscutptr, name, desc, priority::Cint, islpcut::UInt32, benderscutexec, benderscutdata) + ccall((:SCIPincludeBenderscutBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Ptr{SCIP_BENDERSCUT}}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, benderscutptr, name, desc, priority, islpcut, benderscutexec, benderscutdata) +end + +function SCIPsetBenderscutCopy(scip, benderscut, benderscutcopy) + ccall((:SCIPsetBenderscutCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutcopy) +end + +function SCIPsetBenderscutFree(scip, benderscut, benderscutfree) + ccall((:SCIPsetBenderscutFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutfree) +end + +function SCIPsetBenderscutInit(scip, benderscut, benderscutinit) + ccall((:SCIPsetBenderscutInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinit) +end + +function SCIPsetBenderscutExit(scip, benderscut, benderscutexit) + ccall((:SCIPsetBenderscutExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexit) +end + +function SCIPsetBenderscutInitsol(scip, benderscut, benderscutinitsol) + ccall((:SCIPsetBenderscutInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinitsol) +end + +function SCIPsetBenderscutExitsol(scip, benderscut, benderscutexitsol) + ccall((:SCIPsetBenderscutExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexitsol) +end + +function SCIPsetBenderscutPriority(scip, benderscut, priority::Cint) + ccall((:SCIPsetBenderscutPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Cint), scip, benderscut, priority) +end + +function SCIPstoreBenderscutCons(scip, benderscut, cons) + ccall((:SCIPstoreBenderscutCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_CONS}), scip, benderscut, cons) +end + +function SCIPstoreBenderscutCut(scip, benderscut, cut) + ccall((:SCIPstoreBenderscutCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_ROW}), scip, benderscut, cut) +end diff --git a/src/wrapper/scip_branch.jl b/src/wrapper/scip_branch.jl new file mode 100644 index 00000000..d802312f --- /dev/null +++ b/src/wrapper/scip_branch.jl @@ -0,0 +1,199 @@ +# Julia wrapper for header: /usr/include/scip/scip_branch.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeBranchrule(scip, name, desc, priority::Cint, maxdepth::Cint, maxbounddist::Cdouble, branchcopy, branchfree, branchinit, branchexit, branchinitsol, branchexitsol, branchexeclp, branchexecext, branchexecps, branchruledata) + ccall((:SCIPincludeBranchrule, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BRANCHRULEDATA}), scip, name, desc, priority, maxdepth, maxbounddist, branchcopy, branchfree, branchinit, branchexit, branchinitsol, branchexitsol, branchexeclp, branchexecext, branchexecps, branchruledata) +end + +function SCIPincludeBranchruleBasic(scip, branchruleptr, name, desc, priority::Cint, maxdepth::Cint, maxbounddist::Cdouble, branchruledata) + ccall((:SCIPincludeBranchruleBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BRANCHRULE}}, Cstring, Cstring, Cint, Cint, Cdouble, Ptr{SCIP_BRANCHRULEDATA}), scip, branchruleptr, name, desc, priority, maxdepth, maxbounddist, branchruledata) +end + +function SCIPsetBranchruleCopy(scip, branchrule, branchcopy) + ccall((:SCIPsetBranchruleCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchcopy) +end + +function SCIPsetBranchruleFree(scip, branchrule, branchfree) + ccall((:SCIPsetBranchruleFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchfree) +end + +function SCIPsetBranchruleInit(scip, branchrule, branchinit) + ccall((:SCIPsetBranchruleInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinit) +end + +function SCIPsetBranchruleExit(scip, branchrule, branchexit) + ccall((:SCIPsetBranchruleExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexit) +end + +function SCIPsetBranchruleInitsol(scip, branchrule, branchinitsol) + ccall((:SCIPsetBranchruleInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinitsol) +end + +function SCIPsetBranchruleExitsol(scip, branchrule, branchexitsol) + ccall((:SCIPsetBranchruleExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexitsol) +end + +function SCIPsetBranchruleExecLp(scip, branchrule, branchexeclp) + ccall((:SCIPsetBranchruleExecLp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexeclp) +end + +function SCIPsetBranchruleExecExt(scip, branchrule, branchexecext) + ccall((:SCIPsetBranchruleExecExt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecext) +end + +function SCIPsetBranchruleExecPs(scip, branchrule, branchexecps) + ccall((:SCIPsetBranchruleExecPs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecps) +end + +function SCIPfindBranchrule(scip, name) + ccall((:SCIPfindBranchrule, libscip), Ptr{SCIP_BRANCHRULE}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetBranchrules(scip) + ccall((:SCIPgetBranchrules, libscip), Ptr{Ptr{SCIP_BRANCHRULE}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNBranchrules(scip) + ccall((:SCIPgetNBranchrules, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetBranchrulePriority(scip, branchrule, priority::Cint) + ccall((:SCIPsetBranchrulePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, priority) +end + +function SCIPsetBranchruleMaxdepth(scip, branchrule, maxdepth::Cint) + ccall((:SCIPsetBranchruleMaxdepth, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, maxdepth) +end + +function SCIPsetBranchruleMaxbounddist(scip, branchrule, maxbounddist::Cdouble) + ccall((:SCIPsetBranchruleMaxbounddist, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cdouble), scip, branchrule, maxbounddist) +end + +function SCIPgetLPBranchCands(scip, lpcands, lpcandssol, lpcandsfrac, nlpcands, npriolpcands, nfracimplvars) + ccall((:SCIPgetLPBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, lpcands, lpcandssol, lpcandsfrac, nlpcands, npriolpcands, nfracimplvars) +end + +function SCIPgetNLPBranchCands(scip) + ccall((:SCIPgetNLPBranchCands, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioLPBranchCands(scip) + ccall((:SCIPgetNPrioLPBranchCands, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetExternBranchCands(scip, externcands, externcandssol, externcandsscore, nexterncands, nprioexterncands, nprioexternbins, nprioexternints, nprioexternimpls) + ccall((:SCIPgetExternBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, externcands, externcandssol, externcandsscore, nexterncands, nprioexterncands, nprioexternbins, nprioexternints, nprioexternimpls) +end + +function SCIPgetNExternBranchCands(scip) + ccall((:SCIPgetNExternBranchCands, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioExternBranchCands(scip) + ccall((:SCIPgetNPrioExternBranchCands, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioExternBranchBins(scip) + ccall((:SCIPgetNPrioExternBranchBins, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioExternBranchInts(scip) + ccall((:SCIPgetNPrioExternBranchInts, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioExternBranchImpls(scip) + ccall((:SCIPgetNPrioExternBranchImpls, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioExternBranchConts(scip) + ccall((:SCIPgetNPrioExternBranchConts, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPaddExternBranchCand(scip, var, score::Cdouble, solval::Cdouble) + ccall((:SCIPaddExternBranchCand, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, score, solval) +end + +function SCIPclearExternBranchCands(scip) + ccall((:SCIPclearExternBranchCands, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPcontainsExternBranchCand(scip, var) + ccall((:SCIPcontainsExternBranchCand, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetPseudoBranchCands(scip, pseudocands, npseudocands, npriopseudocands) + ccall((:SCIPgetPseudoBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}), scip, pseudocands, npseudocands, npriopseudocands) +end + +function SCIPgetNPseudoBranchCands(scip) + ccall((:SCIPgetNPseudoBranchCands, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioPseudoBranchCands(scip) + ccall((:SCIPgetNPrioPseudoBranchCands, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioPseudoBranchBins(scip) + ccall((:SCIPgetNPrioPseudoBranchBins, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioPseudoBranchInts(scip) + ccall((:SCIPgetNPrioPseudoBranchInts, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrioPseudoBranchImpls(scip) + ccall((:SCIPgetNPrioPseudoBranchImpls, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetBranchScore(scip, var, downgain::Cdouble, upgain::Cdouble) + ccall((:SCIPgetBranchScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, downgain, upgain) +end + +function SCIPgetBranchScoreMultiple(scip, var, nchildren::Cint, gains) + ccall((:SCIPgetBranchScoreMultiple, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, nchildren, gains) +end + +function SCIPgetBranchingPoint(scip, var, suggestion::Cdouble) + ccall((:SCIPgetBranchingPoint, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, suggestion) +end + +function SCIPcalcNodeselPriority(scip, var, branchdir::SCIP_BRANCHDIR, targetvalue::Cdouble) + ccall((:SCIPcalcNodeselPriority, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), scip, var, branchdir, targetvalue) +end + +function SCIPcalcChildEstimate(scip, var, targetvalue::Cdouble) + ccall((:SCIPcalcChildEstimate, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, targetvalue) +end + +function SCIPcreateChild(scip, node, nodeselprio::Cdouble, estimate::Cdouble) + ccall((:SCIPcreateChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NODE}}, Cdouble, Cdouble), scip, node, nodeselprio, estimate) +end + +function SCIPbranchVar(scip, var, downchild, eqchild, upchild) + ccall((:SCIPbranchVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, downchild, eqchild, upchild) +end + +function SCIPbranchVarHole(scip, var, left::Cdouble, right::Cdouble, downchild, upchild) + ccall((:SCIPbranchVarHole, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, left, right, downchild, upchild) +end + +function SCIPbranchVarVal(scip, var, val::Cdouble, downchild, eqchild, upchild) + ccall((:SCIPbranchVarVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, val, downchild, eqchild, upchild) +end + +function SCIPbranchVarValNary(scip, var, val::Cdouble, n::Cint, minwidth::Cdouble, widthfactor::Cdouble, nchildren) + ccall((:SCIPbranchVarValNary, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cint, Cdouble, Cdouble, Ptr{Cint}), scip, var, val, n, minwidth, widthfactor, nchildren) +end + +function SCIPbranchLP(scip, result) + ccall((:SCIPbranchLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) +end + +function SCIPbranchExtern(scip, result) + ccall((:SCIPbranchExtern, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) +end + +function SCIPbranchPseudo(scip, result) + ccall((:SCIPbranchPseudo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) +end diff --git a/src/wrapper/scip_compr.jl b/src/wrapper/scip_compr.jl new file mode 100644 index 00000000..8873fa67 --- /dev/null +++ b/src/wrapper/scip_compr.jl @@ -0,0 +1,51 @@ +# Julia wrapper for header: /usr/include/scip/scip_compr.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeCompr(scip, name, desc, priority::Cint, minnnodes::Cint, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) + ccall((:SCIPincludeCompr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, name, desc, priority, minnnodes, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) +end + +function SCIPincludeComprBasic(scip, compr, name, desc, priority::Cint, minnnodes::Cint, comprexec, comprdata) + ccall((:SCIPincludeComprBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_COMPR}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, compr, name, desc, priority, minnnodes, comprexec, comprdata) +end + +function SCIPsetComprCopy(scip, compr, comprcopy) + ccall((:SCIPsetComprCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprcopy) +end + +function SCIPsetComprFree(scip, compr, comprfree) + ccall((:SCIPsetComprFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprfree) +end + +function SCIPsetComprInit(scip, compr, comprinit) + ccall((:SCIPsetComprInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinit) +end + +function SCIPsetComprExit(scip, compr, comprexit) + ccall((:SCIPsetComprExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexit) +end + +function SCIPsetComprInitsol(scip, compr, comprinitsol) + ccall((:SCIPsetComprInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinitsol) +end + +function SCIPsetComprExitsol(scip, compr, comprexitsol) + ccall((:SCIPsetComprExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexitsol) +end + +function SCIPfindCompr(scip, name) + ccall((:SCIPfindCompr, libscip), Ptr{SCIP_COMPR}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetComprs(scip) + ccall((:SCIPgetComprs, libscip), Ptr{Ptr{SCIP_COMPR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNCompr(scip) + ccall((:SCIPgetNCompr, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetComprPriority(scip, compr, priority::Cint) + ccall((:SCIPsetComprPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Cint), scip, compr, priority) +end diff --git a/src/wrapper/scip_concurrent.jl b/src/wrapper/scip_concurrent.jl new file mode 100644 index 00000000..4c969f1c --- /dev/null +++ b/src/wrapper/scip_concurrent.jl @@ -0,0 +1,31 @@ +# Julia wrapper for header: /usr/include/scip/scip_concurrent.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeConcsolverType(scip, name, prefpriodefault::Cdouble, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) + ccall((:SCIPincludeConcsolverType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONCSOLVERTYPEDATA}), scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) +end + +function SCIPfindConcsolverType(scip, name) + ccall((:SCIPfindConcsolverType, libscip), Ptr{SCIP_CONCSOLVERTYPE}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetConcsolverTypes(scip) + ccall((:SCIPgetConcsolverTypes, libscip), Ptr{Ptr{SCIP_CONCSOLVERTYPE}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNConcsolverTypes(scip) + ccall((:SCIPgetNConcsolverTypes, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPconstructSyncstore(scip) + ccall((:SCIPconstructSyncstore, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPfreeSyncstore(scip) + ccall((:SCIPfreeSyncstore, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetSyncstore(scip) + ccall((:SCIPgetSyncstore, libscip), Ptr{SCIP_SYNCSTORE}, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_conflict.jl b/src/wrapper/scip_conflict.jl new file mode 100644 index 00000000..27bf1cbe --- /dev/null +++ b/src/wrapper/scip_conflict.jl @@ -0,0 +1,107 @@ +# Julia wrapper for header: /usr/include/scip/scip_conflict.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeConflicthdlr(scip, name, desc, priority::Cint, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) + ccall((:SCIPincludeConflicthdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, name, desc, priority, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) +end + +function SCIPincludeConflicthdlrBasic(scip, conflicthdlrptr, name, desc, priority::Cint, conflictexec, conflicthdlrdata) + ccall((:SCIPincludeConflicthdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONFLICTHDLR}}, Cstring, Cstring, Cint, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, conflicthdlrptr, name, desc, priority, conflictexec, conflicthdlrdata) +end + +function SCIPsetConflicthdlrCopy(scip, conflicthdlr, conflictcopy) + ccall((:SCIPsetConflicthdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictcopy) +end + +function SCIPsetConflicthdlrFree(scip, conflicthdlr, conflictfree) + ccall((:SCIPsetConflicthdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictfree) +end + +function SCIPsetConflicthdlrInit(scip, conflicthdlr, conflictinit) + ccall((:SCIPsetConflicthdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinit) +end + +function SCIPsetConflicthdlrExit(scip, conflicthdlr, conflictexit) + ccall((:SCIPsetConflicthdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexit) +end + +function SCIPsetConflicthdlrInitsol(scip, conflicthdlr, conflictinitsol) + ccall((:SCIPsetConflicthdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinitsol) +end + +function SCIPsetConflicthdlrExitsol(scip, conflicthdlr, conflictexitsol) + ccall((:SCIPsetConflicthdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexitsol) +end + +function SCIPfindConflicthdlr(scip, name) + ccall((:SCIPfindConflicthdlr, libscip), Ptr{SCIP_CONFLICTHDLR}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetConflicthdlrs(scip) + ccall((:SCIPgetConflicthdlrs, libscip), Ptr{Ptr{SCIP_CONFLICTHDLR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNConflicthdlrs(scip) + ccall((:SCIPgetNConflicthdlrs, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetConflicthdlrPriority(scip, conflicthdlr, priority::Cint) + ccall((:SCIPsetConflicthdlrPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Cint), scip, conflicthdlr, priority) +end + +function SCIPisConflictAnalysisApplicable(scip) + ccall((:SCIPisConflictAnalysisApplicable, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPinitConflictAnalysis(scip, conftype::SCIP_CONFTYPE, iscutoffinvolved::UInt32) + ccall((:SCIPinitConflictAnalysis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_CONFTYPE, UInt32), scip, conftype, iscutoffinvolved) +end + +function SCIPaddConflictLb(scip, var, bdchgidx) + ccall((:SCIPaddConflictLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) +end + +function SCIPaddConflictRelaxedLb(scip, var, bdchgidx, relaxedlb::Cdouble) + ccall((:SCIPaddConflictRelaxedLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedlb) +end + +function SCIPaddConflictUb(scip, var, bdchgidx) + ccall((:SCIPaddConflictUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) +end + +function SCIPaddConflictRelaxedUb(scip, var, bdchgidx, relaxedub::Cdouble) + ccall((:SCIPaddConflictRelaxedUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedub) +end + +function SCIPaddConflictBd(scip, var, boundtype::SCIP_BOUNDTYPE, bdchgidx) + ccall((:SCIPaddConflictBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}), scip, var, boundtype, bdchgidx) +end + +function SCIPaddConflictRelaxedBd(scip, var, boundtype::SCIP_BOUNDTYPE, bdchgidx, relaxedbd::Cdouble) + ccall((:SCIPaddConflictRelaxedBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, boundtype, bdchgidx, relaxedbd) +end + +function SCIPaddConflictBinvar(scip, var) + ccall((:SCIPaddConflictBinvar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPisConflictVarUsed(scip, var, boundtype::SCIP_BOUNDTYPE, bdchgidx, used) + ccall((:SCIPisConflictVarUsed, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Ptr{UInt32}), scip, var, boundtype, bdchgidx, used) +end + +function SCIPgetConflictVarLb(scip, var) + ccall((:SCIPgetConflictVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetConflictVarUb(scip, var) + ccall((:SCIPgetConflictVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPanalyzeConflict(scip, validdepth::Cint, success) + ccall((:SCIPanalyzeConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}), scip, validdepth, success) +end + +function SCIPanalyzeConflictCons(scip, cons, success) + ccall((:SCIPanalyzeConflictCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{UInt32}), scip, cons, success) +end diff --git a/src/wrapper/scip_cons.jl b/src/wrapper/scip_cons.jl new file mode 100644 index 00000000..74b3badc --- /dev/null +++ b/src/wrapper/scip_cons.jl @@ -0,0 +1,319 @@ +# Julia wrapper for header: /usr/include/scip/scip_cons.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeConshdlr(scip, name, desc, sepapriority::Cint, enfopriority::Cint, chckpriority::Cint, sepafreq::Cint, propfreq::Cint, eagerfreq::Cint, maxprerounds::Cint, delaysepa::UInt32, delayprop::UInt32, needscons::UInt32, proptiming::SCIP_PROPTIMING, presoltiming::SCIP_PRESOLTIMING, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol, consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, conshdlrdata) + ccall((:SCIPincludeConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cint, Cint, Cint, Cint, Cint, UInt32, UInt32, UInt32, SCIP_PROPTIMING, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONSHDLRDATA}), scip, name, desc, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol, consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, conshdlrdata) +end + +function SCIPincludeConshdlrBasic(scip, conshdlrptr, name, desc, enfopriority::Cint, chckpriority::Cint, eagerfreq::Cint, needscons::UInt32, consenfolp, consenfops, conscheck, conslock, conshdlrdata) + ccall((:SCIPincludeConshdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONSHDLR}}, Cstring, Cstring, Cint, Cint, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONSHDLRDATA}), scip, conshdlrptr, name, desc, enfopriority, chckpriority, eagerfreq, needscons, consenfolp, consenfops, conscheck, conslock, conshdlrdata) +end + +function SCIPsetConshdlrSepa(scip, conshdlr, conssepalp, conssepasol, sepafreq::Cint, sepapriority::Cint, delaysepa::UInt32) + ccall((:SCIPsetConshdlrSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, UInt32), scip, conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) +end + +function SCIPsetConshdlrProp(scip, conshdlr, consprop, propfreq::Cint, delayprop::UInt32, proptiming::SCIP_PROPTIMING) + ccall((:SCIPsetConshdlrProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, UInt32, SCIP_PROPTIMING), scip, conshdlr, consprop, propfreq, delayprop, proptiming) +end + +function SCIPsetConshdlrEnforelax(scip, conshdlr, consenforelax) + ccall((:SCIPsetConshdlrEnforelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenforelax) +end + +function SCIPsetConshdlrCopy(scip, conshdlr, conshdlrcopy, conscopy) + ccall((:SCIPsetConshdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, conshdlr, conshdlrcopy, conscopy) +end + +function SCIPsetConshdlrFree(scip, conshdlr, consfree) + ccall((:SCIPsetConshdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consfree) +end + +function SCIPsetConshdlrInit(scip, conshdlr, consinit) + ccall((:SCIPsetConshdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinit) +end + +function SCIPsetConshdlrExit(scip, conshdlr, consexit) + ccall((:SCIPsetConshdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexit) +end + +function SCIPsetConshdlrInitsol(scip, conshdlr, consinitsol) + ccall((:SCIPsetConshdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitsol) +end + +function SCIPsetConshdlrExitsol(scip, conshdlr, consexitsol) + ccall((:SCIPsetConshdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitsol) +end + +function SCIPsetConshdlrInitpre(scip, conshdlr, consinitpre) + ccall((:SCIPsetConshdlrInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitpre) +end + +function SCIPsetConshdlrExitpre(scip, conshdlr, consexitpre) + ccall((:SCIPsetConshdlrExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitpre) +end + +function SCIPsetConshdlrPresol(scip, conshdlr, conspresol, maxprerounds::Cint, presoltiming::SCIP_PRESOLTIMING) + ccall((:SCIPsetConshdlrPresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, SCIP_PRESOLTIMING), scip, conshdlr, conspresol, maxprerounds, presoltiming) +end + +function SCIPsetConshdlrDelete(scip, conshdlr, consdelete) + ccall((:SCIPsetConshdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelete) +end + +function SCIPsetConshdlrTrans(scip, conshdlr, constrans) + ccall((:SCIPsetConshdlrTrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, constrans) +end + +function SCIPsetConshdlrInitlp(scip, conshdlr, consinitlp) + ccall((:SCIPsetConshdlrInitlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitlp) +end + +function SCIPsetConshdlrResprop(scip, conshdlr, consresprop) + ccall((:SCIPsetConshdlrResprop, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consresprop) +end + +function SCIPsetConshdlrActive(scip, conshdlr, consactive) + ccall((:SCIPsetConshdlrActive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consactive) +end + +function SCIPsetConshdlrDeactive(scip, conshdlr, consdeactive) + ccall((:SCIPsetConshdlrDeactive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdeactive) +end + +function SCIPsetConshdlrEnable(scip, conshdlr, consenable) + ccall((:SCIPsetConshdlrEnable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenable) +end + +function SCIPsetConshdlrDisable(scip, conshdlr, consdisable) + ccall((:SCIPsetConshdlrDisable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdisable) +end + +function SCIPsetConshdlrDelvars(scip, conshdlr, consdelvars) + ccall((:SCIPsetConshdlrDelvars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelvars) +end + +function SCIPsetConshdlrPrint(scip, conshdlr, consprint) + ccall((:SCIPsetConshdlrPrint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consprint) +end + +function SCIPsetConshdlrParse(scip, conshdlr, consparse) + ccall((:SCIPsetConshdlrParse, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consparse) +end + +function SCIPsetConshdlrGetVars(scip, conshdlr, consgetvars) + ccall((:SCIPsetConshdlrGetVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetvars) +end + +function SCIPsetConshdlrGetNVars(scip, conshdlr, consgetnvars) + ccall((:SCIPsetConshdlrGetNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetnvars) +end + +function SCIPsetConshdlrGetDiveBdChgs(scip, conshdlr, consgetdivebdchgs) + ccall((:SCIPsetConshdlrGetDiveBdChgs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetdivebdchgs) +end + +function SCIPfindConshdlr(scip, name) + ccall((:SCIPfindConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetConshdlrs(scip) + ccall((:SCIPgetConshdlrs, libscip), Ptr{Ptr{SCIP_CONSHDLR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNConshdlrs(scip) + ccall((:SCIPgetNConshdlrs, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPcreateCons(scip, cons, name, conshdlr, consdata, initial::UInt32, separate::UInt32, enforce::UInt32, check::UInt32, propagate::UInt32, _local::UInt32, modifiable::UInt32, dynamic::UInt32, removable::UInt32, stickingatnode::UInt32) + ccall((:SCIPcreateCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONSDATA}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPparseCons(scip, cons, str, initial::UInt32, separate::UInt32, enforce::UInt32, check::UInt32, propagate::UInt32, _local::UInt32, modifiable::UInt32, dynamic::UInt32, removable::UInt32, stickingatnode::UInt32, success) + ccall((:SCIPparseCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Cstring, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, cons, str, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, success) +end + +function SCIPcaptureCons(scip, cons) + ccall((:SCIPcaptureCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPreleaseCons(scip, cons) + ccall((:SCIPreleaseCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}), scip, cons) +end + +function SCIPchgConsName(scip, cons, name) + ccall((:SCIPchgConsName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cstring), scip, cons, name) +end + +function SCIPsetConsInitial(scip, cons, initial::UInt32) + ccall((:SCIPsetConsInitial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, initial) +end + +function SCIPsetConsSeparated(scip, cons, separate::UInt32) + ccall((:SCIPsetConsSeparated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, separate) +end + +function SCIPsetConsEnforced(scip, cons, enforce::UInt32) + ccall((:SCIPsetConsEnforced, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, enforce) +end + +function SCIPsetConsChecked(scip, cons, check::UInt32) + ccall((:SCIPsetConsChecked, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, check) +end + +function SCIPsetConsPropagated(scip, cons, propagate::UInt32) + ccall((:SCIPsetConsPropagated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, propagate) +end + +function SCIPsetConsLocal(scip, cons, _local::UInt32) + ccall((:SCIPsetConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, _local) +end + +function SCIPsetConsModifiable(scip, cons, modifiable::UInt32) + ccall((:SCIPsetConsModifiable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, modifiable) +end + +function SCIPsetConsDynamic(scip, cons, dynamic::UInt32) + ccall((:SCIPsetConsDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, dynamic) +end + +function SCIPsetConsRemovable(scip, cons, removable::UInt32) + ccall((:SCIPsetConsRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, removable) +end + +function SCIPsetConsStickingAtNode(scip, cons, stickingatnode::UInt32) + ccall((:SCIPsetConsStickingAtNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, stickingatnode) +end + +function SCIPupdateConsFlags(scip, cons0, cons1) + ccall((:SCIPupdateConsFlags, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons0, cons1) +end + +function SCIPtransformCons(scip, cons, transcons) + ccall((:SCIPtransformCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) +end + +function SCIPtransformConss(scip, nconss::Cint, conss, transconss) + ccall((:SCIPtransformConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) +end + +function SCIPgetTransformedCons(scip, cons, transcons) + ccall((:SCIPgetTransformedCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) +end + +function SCIPgetTransformedConss(scip, nconss::Cint, conss, transconss) + ccall((:SCIPgetTransformedConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) +end + +function SCIPaddConsAge(scip, cons, deltaage::Cdouble) + ccall((:SCIPaddConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, deltaage) +end + +function SCIPincConsAge(scip, cons) + ccall((:SCIPincConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPresetConsAge(scip, cons) + ccall((:SCIPresetConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPenableCons(scip, cons) + ccall((:SCIPenableCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPdisableCons(scip, cons) + ccall((:SCIPdisableCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPenableConsSeparation(scip, cons) + ccall((:SCIPenableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPdisableConsSeparation(scip, cons) + ccall((:SCIPdisableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPenableConsPropagation(scip, cons) + ccall((:SCIPenableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPdisableConsPropagation(scip, cons) + ccall((:SCIPdisableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPmarkConsPropagate(scip, cons) + ccall((:SCIPmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPunmarkConsPropagate(scip, cons) + ccall((:SCIPunmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPaddConsLocksType(scip, cons, locktype::SCIP_LOCKTYPE, nlockspos::Cint, nlocksneg::Cint) + ccall((:SCIPaddConsLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_LOCKTYPE, Cint, Cint), scip, cons, locktype, nlockspos, nlocksneg) +end + +function SCIPaddConsLocks(scip, cons, nlockspos::Cint, nlocksneg::Cint) + ccall((:SCIPaddConsLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cint, Cint), scip, cons, nlockspos, nlocksneg) +end + +function SCIPcheckCons(scip, cons, sol, checkintegrality::UInt32, checklprows::UInt32, printreason::UInt32, result) + ccall((:SCIPcheckCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, Ptr{SCIP_RESULT}), scip, cons, sol, checkintegrality, checklprows, printreason, result) +end + +function SCIPenfopsCons(scip, cons, solinfeasible::UInt32, objinfeasible::UInt32, result) + ccall((:SCIPenfopsCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32, UInt32, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, objinfeasible, result) +end + +function SCIPenfolpCons(scip, cons, solinfeasible::UInt32, result) + ccall((:SCIPenfolpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, result) +end + +function SCIPenforelaxCons(scip, cons, sol, solinfeasible::UInt32, result) + ccall((:SCIPenforelaxCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, UInt32, Ptr{SCIP_RESULT}), scip, cons, sol, solinfeasible, result) +end + +function SCIPinitlpCons(scip, cons, infeasible) + ccall((:SCIPinitlpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{UInt32}), scip, cons, infeasible) +end + +function SCIPsepalpCons(scip, cons, result) + ccall((:SCIPsepalpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RESULT}), scip, cons, result) +end + +function SCIPsepasolCons(scip, cons, sol, result) + ccall((:SCIPsepasolCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cons, sol, result) +end + +function SCIPpropCons(scip, cons, proptiming::SCIP_PROPTIMING, result) + ccall((:SCIPpropCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_PROPTIMING, Ptr{SCIP_RESULT}), scip, cons, proptiming, result) +end + +function SCIPrespropCons(scip, cons, infervar, inferinfo::Cint, boundtype::SCIP_BOUNDTYPE, bdchgidx, relaxedbd::Cdouble, result) + ccall((:SCIPrespropCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cint, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble, Ptr{SCIP_RESULT}), scip, cons, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, result) +end + +function SCIPpresolCons(scip, cons, nrounds::Cint, presoltiming::SCIP_PRESOLTIMING, nnewfixedvars::Cint, nnewaggrvars::Cint, nnewchgvartypes::Cint, nnewchgbds::Cint, nnewholes::Cint, nnewdelconss::Cint, nnewaddconss::Cint, nnewupgdconss::Cint, nnewchgcoefs::Cint, nnewchgsides::Cint, nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) + ccall((:SCIPpresolCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cint, SCIP_PRESOLTIMING, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{SCIP_RESULT}), scip, cons, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) +end + +function SCIPactiveCons(scip, cons) + ccall((:SCIPactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPdeactiveCons(scip, cons) + ccall((:SCIPdeactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPprintCons(scip, cons, file) + ccall((:SCIPprintCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{FILE}), scip, cons, file) +end + +function SCIPgetConsVars(scip, cons, vars, varssize::Cint, success) + ccall((:SCIPgetConsVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{UInt32}), scip, cons, vars, varssize, success) +end + +function SCIPgetConsNVars(scip, cons, nvars, success) + ccall((:SCIPgetConsNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cint}, Ptr{UInt32}), scip, cons, nvars, success) +end diff --git a/src/wrapper/scip_copy.jl b/src/wrapper/scip_copy.jl new file mode 100644 index 00000000..5f659d3f --- /dev/null +++ b/src/wrapper/scip_copy.jl @@ -0,0 +1,107 @@ +# Julia wrapper for header: /usr/include/scip/scip_copy.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPcopyPlugins(sourcescip, targetscip, copyreaders::UInt32, copypricers::UInt32, copyconshdlrs::UInt32, copyconflicthdlrs::UInt32, copypresolvers::UInt32, copyrelaxators::UInt32, copyseparators::UInt32, copypropagators::UInt32, copyheuristics::UInt32, copyeventhdlrs::UInt32, copynodeselectors::UInt32, copybranchrules::UInt32, copydisplays::UInt32, copydialogs::UInt32, copytables::UInt32, copynlpis::UInt32, passmessagehdlr::UInt32, valid) + ccall((:SCIPcopyPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copydisplays, copydialogs, copytables, copynlpis, passmessagehdlr, valid) +end + +function SCIPcopyBenders(sourcescip, targetscip, varmap, valid) + ccall((:SCIPcopyBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{UInt32}), sourcescip, targetscip, varmap, valid) +end + +function SCIPcopyProb(sourcescip, targetscip, varmap, consmap, _global::UInt32, name) + ccall((:SCIPcopyProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Cstring), sourcescip, targetscip, varmap, consmap, _global, name) +end + +function SCIPcopyOrigProb(sourcescip, targetscip, varmap, consmap, name) + ccall((:SCIPcopyOrigProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring), sourcescip, targetscip, varmap, consmap, name) +end + +function SCIPenableConsCompression(scip) + ccall((:SCIPenableConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPisConsCompressionEnabled(scip) + ccall((:SCIPisConsCompressionEnabled, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetVarCopy(sourcescip, targetscip, sourcevar, targetvar, varmap, consmap, _global::UInt32, success) + ccall((:SCIPgetVarCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}), sourcescip, targetscip, sourcevar, targetvar, varmap, consmap, _global, success) +end + +function SCIPcopyVars(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars::Cint, _global::UInt32) + ccall((:SCIPcopyVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars, _global) +end + +function SCIPcopyOrigVars(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars::Cint) + ccall((:SCIPcopyOrigVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars) +end + +function SCIPmergeVariableStatistics(sourcescip, targetscip, sourcevars, targetvars, nvars::Cint) + ccall((:SCIPmergeVariableStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint), sourcescip, targetscip, sourcevars, targetvars, nvars) +end + +function SCIPgetConsCopy(sourcescip, targetscip, sourcecons, targetcons, sourceconshdlr, varmap, consmap, name, initial::UInt32, separate::UInt32, enforce::UInt32, check::UInt32, propagate::UInt32, _local::UInt32, modifiable::UInt32, dynamic::UInt32, removable::UInt32, stickingatnode::UInt32, _global::UInt32, valid) + ccall((:SCIPgetConsCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, sourcecons, targetcons, sourceconshdlr, varmap, consmap, name, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) +end + +function SCIPcopyConss(sourcescip, targetscip, varmap, consmap, _global::UInt32, enablepricing::UInt32, valid) + ccall((:SCIPcopyConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) +end + +function SCIPcopyOrigConss(sourcescip, targetscip, varmap, consmap, enablepricing::UInt32, valid) + ccall((:SCIPcopyOrigConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, enablepricing, valid) +end + +function SCIPconvertCutsToConss(scip, varmap, consmap, _global::UInt32, ncutsadded) + ccall((:SCIPconvertCutsToConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{Cint}), scip, varmap, consmap, _global, ncutsadded) +end + +function SCIPcopyCuts(sourcescip, targetscip, varmap, consmap, _global::UInt32, ncutsadded) + ccall((:SCIPcopyCuts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, ncutsadded) +end + +function SCIPcopyConflicts(sourcescip, targetscip, varmap, consmap, _global::UInt32, enablepricing::UInt32, valid) + ccall((:SCIPcopyConflicts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) +end + +function SCIPcopyImplicationsCliques(sourcescip, targetscip, varmap, consmap, _global::UInt32, infeasible, nbdchgs, ncopied) + ccall((:SCIPcopyImplicationsCliques, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}, Ptr{Cint}, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, infeasible, nbdchgs, ncopied) +end + +function SCIPcopyParamSettings(sourcescip, targetscip) + ccall((:SCIPcopyParamSettings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}), sourcescip, targetscip) +end + +function SCIPgetSubscipDepth(scip) + ccall((:SCIPgetSubscipDepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetSubscipDepth(scip, newdepth::Cint) + ccall((:SCIPsetSubscipDepth, libscip), Cvoid, (Ptr{SCIP}, Cint), scip, newdepth) +end + +function SCIPcopy(sourcescip, targetscip, varmap, consmap, suffix, _global::UInt32, enablepricing::UInt32, passmessagehdlr::UInt32, valid) + ccall((:SCIPcopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, passmessagehdlr, valid) +end + +function SCIPcopyConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars::Cint, _global::UInt32, enablepricing::UInt32, passmessagehdlr::UInt32, valid) + ccall((:SCIPcopyConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, passmessagehdlr, valid) +end + +function SCIPcopyOrig(sourcescip, targetscip, varmap, consmap, suffix, enablepricing::UInt32, passmessagehdlr::UInt32, valid) + ccall((:SCIPcopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, enablepricing, passmessagehdlr, valid) +end + +function SCIPcopyOrigConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars::Cint, enablepricing::UInt32, passmessagehdlr::UInt32, valid) + ccall((:SCIPcopyOrigConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, passmessagehdlr, valid) +end + +function SCIPcheckCopyLimits(sourcescip, success) + ccall((:SCIPcheckCopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), sourcescip, success) +end + +function SCIPcopyLimits(sourcescip, targetscip) + ccall((:SCIPcopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}), sourcescip, targetscip) +end diff --git a/src/wrapper/scip_cut.jl b/src/wrapper/scip_cut.jl new file mode 100644 index 00000000..41b1e8d1 --- /dev/null +++ b/src/wrapper/scip_cut.jl @@ -0,0 +1,123 @@ +# Julia wrapper for header: /usr/include/scip/scip_cut.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPgetCutEfficacy(scip, sol, cut) + ccall((:SCIPgetCutEfficacy, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) +end + +function SCIPisCutEfficacious(scip, sol, cut) + ccall((:SCIPisCutEfficacious, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) +end + +function SCIPisEfficacious(scip, efficacy::Cdouble) + ccall((:SCIPisEfficacious, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, efficacy) +end + +function SCIPgetVectorEfficacyNorm(scip, vals, nvals::Cint) + ccall((:SCIPgetVectorEfficacyNorm, libscip), Cdouble, (Ptr{SCIP}, Ptr{Cdouble}, Cint), scip, vals, nvals) +end + +function SCIPisCutApplicable(scip, cut) + ccall((:SCIPisCutApplicable, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, cut) +end + +function SCIPaddCut(scip, sol, cut, forcecut::UInt32, infeasible) + ccall((:SCIPaddCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}, UInt32, Ptr{UInt32}), scip, sol, cut, forcecut, infeasible) +end + +function SCIPaddRow(scip, row, forcecut::UInt32, infeasible) + ccall((:SCIPaddRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, UInt32, Ptr{UInt32}), scip, row, forcecut, infeasible) +end + +function SCIPisCutNew(scip, row) + ccall((:SCIPisCutNew, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPaddPoolCut(scip, row) + ccall((:SCIPaddPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPdelPoolCut(scip, row) + ccall((:SCIPdelPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetPoolCuts(scip) + ccall((:SCIPgetPoolCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNPoolCuts(scip) + ccall((:SCIPgetNPoolCuts, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetGlobalCutpool(scip) + ccall((:SCIPgetGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP},), scip) +end + +function SCIPcreateCutpool(scip, cutpool, agelimit::Cint) + ccall((:SCIPcreateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}, Cint), scip, cutpool, agelimit) +end + +function SCIPfreeCutpool(scip, cutpool) + ccall((:SCIPfreeCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}), scip, cutpool) +end + +function SCIPaddRowCutpool(scip, cutpool, row) + ccall((:SCIPaddRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) +end + +function SCIPaddNewRowCutpool(scip, cutpool, row) + ccall((:SCIPaddNewRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) +end + +function SCIPdelRowCutpool(scip, cutpool, row) + ccall((:SCIPdelRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) +end + +function SCIPseparateCutpool(scip, cutpool, result) + ccall((:SCIPseparateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_RESULT}), scip, cutpool, result) +end + +function SCIPseparateSolCutpool(scip, cutpool, sol, result) + ccall((:SCIPseparateSolCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cutpool, sol, result) +end + +function SCIPaddDelayedPoolCut(scip, row) + ccall((:SCIPaddDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPdelDelayedPoolCut(scip, row) + ccall((:SCIPdelDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetDelayedPoolCuts(scip) + ccall((:SCIPgetDelayedPoolCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNDelayedPoolCuts(scip) + ccall((:SCIPgetNDelayedPoolCuts, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetDelayedGlobalCutpool(scip) + ccall((:SCIPgetDelayedGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP},), scip) +end + +function SCIPseparateSol(scip, sol, pretendroot::UInt32, allowlocal::UInt32, onlydelayed::UInt32, delayed, cutoff) + ccall((:SCIPseparateSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, sol, pretendroot, allowlocal, onlydelayed, delayed, cutoff) +end + +function SCIPgetCuts(scip) + ccall((:SCIPgetCuts, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNCuts(scip) + ccall((:SCIPgetNCuts, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPclearCuts(scip) + ccall((:SCIPclearCuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPremoveInefficaciousCuts(scip) + ccall((:SCIPremoveInefficaciousCuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_datastructures.jl b/src/wrapper/scip_datastructures.jl new file mode 100644 index 00000000..87cb9c18 --- /dev/null +++ b/src/wrapper/scip_datastructures.jl @@ -0,0 +1,155 @@ +# Julia wrapper for header: /usr/include/scip/scip_datastructures.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPcreateRealarray(scip, realarray) + ccall((:SCIPcreateRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) +end + +function SCIPfreeRealarray(scip, realarray) + ccall((:SCIPfreeRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) +end + +function SCIPextendRealarray(scip, realarray, minidx::Cint, maxidx::Cint) + ccall((:SCIPextendRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cint), scip, realarray, minidx, maxidx) +end + +function SCIPclearRealarray(scip, realarray) + ccall((:SCIPclearRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) +end + +function SCIPgetRealarrayVal(scip, realarray, idx::Cint) + ccall((:SCIPgetRealarrayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint), scip, realarray, idx) +end + +function SCIPsetRealarrayVal(scip, realarray, idx::Cint, val::Cdouble) + ccall((:SCIPsetRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, val) +end + +function SCIPincRealarrayVal(scip, realarray, idx::Cint, incval::Cdouble) + ccall((:SCIPincRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, incval) +end + +function SCIPgetRealarrayMinIdx(scip, realarray) + ccall((:SCIPgetRealarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) +end + +function SCIPgetRealarrayMaxIdx(scip, realarray) + ccall((:SCIPgetRealarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) +end + +function SCIPcreateIntarray(scip, intarray) + ccall((:SCIPcreateIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) +end + +function SCIPfreeIntarray(scip, intarray) + ccall((:SCIPfreeIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) +end + +function SCIPextendIntarray(scip, intarray, minidx::Cint, maxidx::Cint) + ccall((:SCIPextendIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, minidx, maxidx) +end + +function SCIPclearIntarray(scip, intarray) + ccall((:SCIPclearIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) +end + +function SCIPgetIntarrayVal(scip, intarray, idx::Cint) + ccall((:SCIPgetIntarrayVal, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint), scip, intarray, idx) +end + +function SCIPsetIntarrayVal(scip, intarray, idx::Cint, val::Cint) + ccall((:SCIPsetIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, val) +end + +function SCIPincIntarrayVal(scip, intarray, idx::Cint, incval::Cint) + ccall((:SCIPincIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, incval) +end + +function SCIPgetIntarrayMinIdx(scip, intarray) + ccall((:SCIPgetIntarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) +end + +function SCIPgetIntarrayMaxIdx(scip, intarray) + ccall((:SCIPgetIntarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) +end + +function SCIPcreateBoolarray(scip, boolarray) + ccall((:SCIPcreateBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) +end + +function SCIPfreeBoolarray(scip, boolarray) + ccall((:SCIPfreeBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) +end + +function SCIPextendBoolarray(scip, boolarray, minidx::Cint, maxidx::Cint) + ccall((:SCIPextendBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cint), scip, boolarray, minidx, maxidx) +end + +function SCIPclearBoolarray(scip, boolarray) + ccall((:SCIPclearBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) +end + +function SCIPgetBoolarrayVal(scip, boolarray, idx::Cint) + ccall((:SCIPgetBoolarrayVal, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint), scip, boolarray, idx) +end + +function SCIPsetBoolarrayVal(scip, boolarray, idx::Cint, val::UInt32) + ccall((:SCIPsetBoolarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, UInt32), scip, boolarray, idx, val) +end + +function SCIPgetBoolarrayMinIdx(scip, boolarray) + ccall((:SCIPgetBoolarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) +end + +function SCIPgetBoolarrayMaxIdx(scip, boolarray) + ccall((:SCIPgetBoolarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) +end + +function SCIPcreatePtrarray(scip, ptrarray) + ccall((:SCIPcreatePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) +end + +function SCIPfreePtrarray(scip, ptrarray) + ccall((:SCIPfreePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) +end + +function SCIPextendPtrarray(scip, ptrarray, minidx::Cint, maxidx::Cint) + ccall((:SCIPextendPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Cint), scip, ptrarray, minidx, maxidx) +end + +function SCIPclearPtrarray(scip, ptrarray) + ccall((:SCIPclearPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) +end + +function SCIPgetPtrarrayVal(scip, ptrarray, idx::Cint) + ccall((:SCIPgetPtrarrayVal, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint), scip, ptrarray, idx) +end + +function SCIPsetPtrarrayVal(scip, ptrarray, idx::Cint, val) + ccall((:SCIPsetPtrarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Ptr{Cvoid}), scip, ptrarray, idx, val) +end + +function SCIPgetPtrarrayMinIdx(scip, ptrarray) + ccall((:SCIPgetPtrarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) +end + +function SCIPgetPtrarrayMaxIdx(scip, ptrarray) + ccall((:SCIPgetPtrarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) +end + +function SCIPcreateDisjointset(scip, djset, ncomponents::Cint) + ccall((:SCIPcreateDisjointset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}, Cint), scip, djset, ncomponents) +end + +function SCIPfreeDisjointset(scip, djset) + ccall((:SCIPfreeDisjointset, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}), scip, djset) +end + +function SCIPcreateDigraph(scip, digraph, nnodes::Cint) + ccall((:SCIPcreateDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Cint), scip, digraph, nnodes) +end + +function SCIPcopyDigraph(scip, targetdigraph, sourcedigraph) + ccall((:SCIPcopyDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Ptr{SCIP_DIGRAPH}), scip, targetdigraph, sourcedigraph) +end diff --git a/src/wrapper/scip_debug.jl b/src/wrapper/scip_debug.jl new file mode 100644 index 00000000..f14abed2 --- /dev/null +++ b/src/wrapper/scip_debug.jl @@ -0,0 +1,11 @@ +# Julia wrapper for header: /usr/include/scip/scip_debug.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPenableDebugSol(scip) + ccall((:SCIPenableDebugSol, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPdisableDebugSol(scip) + ccall((:SCIPdisableDebugSol, libscip), Cvoid, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_dialog.jl b/src/wrapper/scip_dialog.jl new file mode 100644 index 00000000..fbd88a9e --- /dev/null +++ b/src/wrapper/scip_dialog.jl @@ -0,0 +1,43 @@ +# Julia wrapper for header: /usr/include/scip/scip_dialog.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeDialog(scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu::UInt32, dialogdata) + ccall((:SCIPincludeDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cstring, Cstring, UInt32, Ptr{SCIP_DIALOGDATA}), scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu, dialogdata) +end + +function SCIPexistsDialog(scip, dialog) + ccall((:SCIPexistsDialog, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) +end + +function SCIPcaptureDialog(scip, dialog) + ccall((:SCIPcaptureDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) +end + +function SCIPreleaseDialog(scip, dialog) + ccall((:SCIPreleaseDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog) +end + +function SCIPsetRootDialog(scip, dialog) + ccall((:SCIPsetRootDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) +end + +function SCIPgetRootDialog(scip) + ccall((:SCIPgetRootDialog, libscip), Ptr{SCIP_DIALOG}, (Ptr{SCIP},), scip) +end + +function SCIPaddDialogEntry(scip, dialog, subdialog) + ccall((:SCIPaddDialogEntry, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOG}), scip, dialog, subdialog) +end + +function SCIPaddDialogInputLine(scip, inputline) + ccall((:SCIPaddDialogInputLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, inputline) +end + +function SCIPaddDialogHistoryLine(scip, inputline) + ccall((:SCIPaddDialogHistoryLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, inputline) +end + +function SCIPstartInteraction(scip) + ccall((:SCIPstartInteraction, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_disp.jl b/src/wrapper/scip_disp.jl new file mode 100644 index 00000000..e7ac4a89 --- /dev/null +++ b/src/wrapper/scip_disp.jl @@ -0,0 +1,27 @@ +# Julia wrapper for header: /usr/include/scip/scip_disp.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeDisp(scip, name, desc, header, dispstatus::SCIP_DISPSTATUS, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width::Cint, priority::Cint, position::Cint, stripline::UInt32) + ccall((:SCIPincludeDisp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cstring, SCIP_DISPSTATUS, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_DISPDATA}, Cint, Cint, Cint, UInt32), scip, name, desc, header, dispstatus, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width, priority, position, stripline) +end + +function SCIPfindDisp(scip, name) + ccall((:SCIPfindDisp, libscip), Ptr{SCIP_DISP}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetDisps(scip) + ccall((:SCIPgetDisps, libscip), Ptr{Ptr{SCIP_DISP}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNDisps(scip) + ccall((:SCIPgetNDisps, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPautoselectDisps(scip) + ccall((:SCIPautoselectDisps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPchgDispMode(disp, mode::SCIP_DISPMODE) + ccall((:SCIPchgDispMode, libscip), Cvoid, (Ptr{SCIP_DISP}, SCIP_DISPMODE), disp, mode) +end diff --git a/src/wrapper/scip_event.jl b/src/wrapper/scip_event.jl new file mode 100644 index 00000000..27272af1 --- /dev/null +++ b/src/wrapper/scip_event.jl @@ -0,0 +1,75 @@ +# Julia wrapper for header: /usr/include/scip/scip_event.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeEventhdlr(scip, name, desc, eventcopy, eventfree, eventinit, eventexit, eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata) + ccall((:SCIPincludeEventhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_EVENTHDLRDATA}), scip, name, desc, eventcopy, eventfree, eventinit, eventexit, eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata) +end + +function SCIPincludeEventhdlrBasic(scip, eventhdlrptr, name, desc, eventexec, eventhdlrdata) + ccall((:SCIPincludeEventhdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EVENTHDLR}}, Cstring, Cstring, Ptr{Cvoid}, Ptr{SCIP_EVENTHDLRDATA}), scip, eventhdlrptr, name, desc, eventexec, eventhdlrdata) +end + +function SCIPsetEventhdlrCopy(scip, eventhdlr, eventcopy) + ccall((:SCIPsetEventhdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventcopy) +end + +function SCIPsetEventhdlrFree(scip, eventhdlr, eventfree) + ccall((:SCIPsetEventhdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventfree) +end + +function SCIPsetEventhdlrInit(scip, eventhdlr, eventinit) + ccall((:SCIPsetEventhdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinit) +end + +function SCIPsetEventhdlrExit(scip, eventhdlr, eventexit) + ccall((:SCIPsetEventhdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexit) +end + +function SCIPsetEventhdlrInitsol(scip, eventhdlr, eventinitsol) + ccall((:SCIPsetEventhdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinitsol) +end + +function SCIPsetEventhdlrExitsol(scip, eventhdlr, eventexitsol) + ccall((:SCIPsetEventhdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexitsol) +end + +function SCIPsetEventhdlrDelete(scip, eventhdlr, eventdelete) + ccall((:SCIPsetEventhdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventdelete) +end + +function SCIPfindEventhdlr(scip, name) + ccall((:SCIPfindEventhdlr, libscip), Ptr{SCIP_EVENTHDLR}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetEventhdlrs(scip) + ccall((:SCIPgetEventhdlrs, libscip), Ptr{Ptr{SCIP_EVENTHDLR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNEventhdlrs(scip) + ccall((:SCIPgetNEventhdlrs, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPcatchEvent(scip, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos) + ccall((:SCIPcatchEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, eventtype, eventhdlr, eventdata, filterpos) +end + +function SCIPdropEvent(scip, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos::Cint) + ccall((:SCIPdropEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, eventtype, eventhdlr, eventdata, filterpos) +end + +function SCIPcatchVarEvent(scip, var, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos) + ccall((:SCIPcatchVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, var, eventtype, eventhdlr, eventdata, filterpos) +end + +function SCIPdropVarEvent(scip, var, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos::Cint) + ccall((:SCIPdropVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, var, eventtype, eventhdlr, eventdata, filterpos) +end + +function SCIPcatchRowEvent(scip, row, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos) + ccall((:SCIPcatchRowEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, row, eventtype, eventhdlr, eventdata, filterpos) +end + +function SCIPdropRowEvent(scip, row, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos::Cint) + ccall((:SCIPdropRowEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, row, eventtype, eventhdlr, eventdata, filterpos) +end diff --git a/src/wrapper/scip_expr.jl b/src/wrapper/scip_expr.jl new file mode 100644 index 00000000..adc33479 --- /dev/null +++ b/src/wrapper/scip_expr.jl @@ -0,0 +1,19 @@ +# Julia wrapper for header: /usr/include/scip/scip_expr.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPgetExprtreeTransformedVars(scip, tree) + ccall((:SCIPgetExprtreeTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}), scip, tree) +end + +function SCIPevalExprtreeSol(scip, tree, sol, val) + ccall((:SCIPevalExprtreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, tree, sol, val) +end + +function SCIPevalExprtreeGlobalBounds(scip, tree, infinity::Cdouble, val) + ccall((:SCIPevalExprtreeGlobalBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Cdouble, Ptr{Cint}), scip, tree, infinity, val) +end + +function SCIPevalExprtreeLocalBounds(scip, tree, infinity::Cdouble, val) + ccall((:SCIPevalExprtreeLocalBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Cdouble, Ptr{Cint}), scip, tree, infinity, val) +end diff --git a/src/wrapper/scip_general.jl b/src/wrapper/scip_general.jl new file mode 100644 index 00000000..aeacb5a1 --- /dev/null +++ b/src/wrapper/scip_general.jl @@ -0,0 +1,103 @@ +# Julia wrapper for header: /usr/include/scip/scip_general.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPversion() + ccall((:SCIPversion, libscip), Cdouble, ()) +end + +function SCIPmajorVersion() + ccall((:SCIPmajorVersion, libscip), Cint, ()) +end + +function SCIPminorVersion() + ccall((:SCIPminorVersion, libscip), Cint, ()) +end + +function SCIPtechVersion() + ccall((:SCIPtechVersion, libscip), Cint, ()) +end + +function SCIPsubversion() + ccall((:SCIPsubversion, libscip), Cint, ()) +end + +function SCIPprintVersion(scip, file) + ccall((:SCIPprintVersion, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintBuildOptions(scip, file) + ccall((:SCIPprintBuildOptions, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintError(retcode::SCIP_RETCODE) + ccall((:SCIPprintError, libscip), Cvoid, (SCIP_RETCODE,), retcode) +end + +function SCIPcreate(scip) + ccall((:SCIPcreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP}},), scip) +end + +function SCIPfree(scip) + ccall((:SCIPfree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP}},), scip) +end + +function SCIPgetStage(scip) + ccall((:SCIPgetStage, libscip), SCIP_STAGE, (Ptr{SCIP},), scip) +end + +function SCIPprintStage(scip, file) + ccall((:SCIPprintStage, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPgetStatus(scip) + ccall((:SCIPgetStatus, libscip), SCIP_STATUS, (Ptr{SCIP},), scip) +end + +function SCIPprintStatus(scip, file) + ccall((:SCIPprintStatus, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPisTransformed(scip) + ccall((:SCIPisTransformed, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPisExactSolve(scip) + ccall((:SCIPisExactSolve, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPisPresolveFinished(scip) + ccall((:SCIPisPresolveFinished, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPhasPerformedPresolve(scip) + ccall((:SCIPhasPerformedPresolve, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPpressedCtrlC(scip) + ccall((:SCIPpressedCtrlC, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPisStopped(scip) + ccall((:SCIPisStopped, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPincludeExternalCodeInformation(scip, name, description) + ccall((:SCIPincludeExternalCodeInformation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, name, description) +end + +function SCIPgetExternalCodeNames(scip) + ccall((:SCIPgetExternalCodeNames, libscip), Ptr{Cstring}, (Ptr{SCIP},), scip) +end + +function SCIPgetExternalCodeDescriptions(scip) + ccall((:SCIPgetExternalCodeDescriptions, libscip), Ptr{Cstring}, (Ptr{SCIP},), scip) +end + +function SCIPgetNExternalCodes(scip) + ccall((:SCIPgetNExternalCodes, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPprintExternalCodes(scip, file) + ccall((:SCIPprintExternalCodes, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end diff --git a/src/wrapper/scip_heur.jl b/src/wrapper/scip_heur.jl new file mode 100644 index 00000000..b45a4b8e --- /dev/null +++ b/src/wrapper/scip_heur.jl @@ -0,0 +1,55 @@ +# Julia wrapper for header: /usr/include/scip/scip_heur.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeHeur(scip, name, desc, dispchar::UInt8, priority::Cint, freq::Cint, freqofs::Cint, maxdepth::Cint, timingmask::SCIP_HEURTIMING, usessubscip::UInt32, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) + ccall((:SCIPincludeHeur, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt8, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) +end + +function SCIPincludeHeurBasic(scip, heur, name, desc, dispchar::UInt8, priority::Cint, freq::Cint, freqofs::Cint, maxdepth::Cint, timingmask::SCIP_HEURTIMING, usessubscip::UInt32, heurexec, heurdata) + ccall((:SCIPincludeHeurBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_HEUR}}, Cstring, Cstring, UInt8, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, UInt32, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, heur, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurexec, heurdata) +end + +function SCIPsetHeurCopy(scip, heur, heurcopy) + ccall((:SCIPsetHeurCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurcopy) +end + +function SCIPsetHeurFree(scip, heur, heurfree) + ccall((:SCIPsetHeurFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurfree) +end + +function SCIPsetHeurInit(scip, heur, heurinit) + ccall((:SCIPsetHeurInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinit) +end + +function SCIPsetHeurExit(scip, heur, heurexit) + ccall((:SCIPsetHeurExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexit) +end + +function SCIPsetHeurInitsol(scip, heur, heurinitsol) + ccall((:SCIPsetHeurInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinitsol) +end + +function SCIPsetHeurExitsol(scip, heur, heurexitsol) + ccall((:SCIPsetHeurExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexitsol) +end + +function SCIPfindHeur(scip, name) + ccall((:SCIPfindHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetHeurs(scip) + ccall((:SCIPgetHeurs, libscip), Ptr{Ptr{SCIP_HEUR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNHeurs(scip) + ccall((:SCIPgetNHeurs, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetHeurPriority(scip, heur, priority::Cint) + ccall((:SCIPsetHeurPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Cint), scip, heur, priority) +end + +function SCIPcreateDiveset(scip, diveset, heur, name, minreldepth::Cdouble, maxreldepth::Cdouble, maxlpiterquot::Cdouble, maxdiveubquot::Cdouble, maxdiveavgquot::Cdouble, maxdiveubquotnosol::Cdouble, maxdiveavgquotnosol::Cdouble, lpresolvedomchgquot::Cdouble, lpsolvefreq::Cint, maxlpiterofs::Cint, initialseed::UInt32, backtrack::UInt32, onlylpbranchcands::UInt32, specificsos1score::UInt32, divesetgetscore) + ccall((:SCIPcreateDiveset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIVESET}}, Ptr{SCIP_HEUR}, Cstring, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}), scip, diveset, heur, name, minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol, maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack, onlylpbranchcands, specificsos1score, divesetgetscore) +end diff --git a/src/wrapper/scip_lp.jl b/src/wrapper/scip_lp.jl new file mode 100644 index 00000000..27a18481 --- /dev/null +++ b/src/wrapper/scip_lp.jl @@ -0,0 +1,367 @@ +# Julia wrapper for header: /usr/include/scip/scip_lp.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPhasCurrentNodeLP(scip) + ccall((:SCIPhasCurrentNodeLP, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPisLPConstructed(scip) + ccall((:SCIPisLPConstructed, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPconstructLP(scip, cutoff) + ccall((:SCIPconstructLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) +end + +function SCIPflushLP(scip) + ccall((:SCIPflushLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetLPSolstat(scip) + ccall((:SCIPgetLPSolstat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP},), scip) +end + +function SCIPisLPPrimalReliable(scip) + ccall((:SCIPisLPPrimalReliable, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPisLPDualReliable(scip) + ccall((:SCIPisLPDualReliable, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPisLPRelax(scip) + ccall((:SCIPisLPRelax, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetLPObjval(scip) + ccall((:SCIPgetLPObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLPColumnObjval(scip) + ccall((:SCIPgetLPColumnObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLPLooseObjval(scip) + ccall((:SCIPgetLPLooseObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetGlobalPseudoObjval(scip) + ccall((:SCIPgetGlobalPseudoObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetPseudoObjval(scip) + ccall((:SCIPgetPseudoObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPisRootLPRelax(scip) + ccall((:SCIPisRootLPRelax, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetLPRootObjval(scip) + ccall((:SCIPgetLPRootObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLPRootColumnObjval(scip) + ccall((:SCIPgetLPRootColumnObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLPRootLooseObjval(scip) + ccall((:SCIPgetLPRootLooseObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLPColsData(scip, cols, ncols) + ccall((:SCIPgetLPColsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_COL}}}, Ptr{Cint}), scip, cols, ncols) +end + +function SCIPgetLPCols(scip) + ccall((:SCIPgetLPCols, libscip), Ptr{Ptr{SCIP_COL}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPCols(scip) + ccall((:SCIPgetNLPCols, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetLPRowsData(scip, rows, nrows) + ccall((:SCIPgetLPRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_ROW}}}, Ptr{Cint}), scip, rows, nrows) +end + +function SCIPgetLPRows(scip) + ccall((:SCIPgetLPRows, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPRows(scip) + ccall((:SCIPgetNLPRows, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPallColsInLP(scip) + ccall((:SCIPallColsInLP, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPisLPSolBasic(scip) + ccall((:SCIPisLPSolBasic, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetLPBasisInd(scip, basisind) + ccall((:SCIPgetLPBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, basisind) +end + +function SCIPgetLPBInvRow(scip, r::Cint, coefs, inds, ninds) + ccall((:SCIPgetLPBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, coefs, inds, ninds) +end + +function SCIPgetLPBInvCol(scip, c::Cint, coefs, inds, ninds) + ccall((:SCIPgetLPBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) +end + +function SCIPgetLPBInvARow(scip, r::Cint, binvrow, coefs, inds, ninds) + ccall((:SCIPgetLPBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, binvrow, coefs, inds, ninds) +end + +function SCIPgetLPBInvACol(scip, c::Cint, coefs, inds, ninds) + ccall((:SCIPgetLPBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) +end + +function SCIPsumLPRows(scip, weights, sumcoef, sumlhs, sumrhs) + ccall((:SCIPsumLPRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}, Ptr{SCIP_REALARRAY}, Ptr{Cdouble}, Ptr{Cdouble}), scip, weights, sumcoef, sumlhs, sumrhs) +end + +function SCIPwriteLP(scip, filename) + ccall((:SCIPwriteLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) +end + +function SCIPwriteMIP(scip, filename, genericnames::UInt32, origobj::UInt32, lazyconss::UInt32) + ccall((:SCIPwriteMIP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32, UInt32, UInt32), scip, filename, genericnames, origobj, lazyconss) +end + +function SCIPgetLPI(scip, lpi) + ccall((:SCIPgetLPI, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LPI}}), scip, lpi) +end + +function SCIPprintLPSolutionQuality(scip, file) + ccall((:SCIPprintLPSolutionQuality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPcomputeLPRelIntPoint(scip, relaxrows::UInt32, inclobjcutoff::UInt32, timelimit::Cdouble, iterlimit::Cint, point) + ccall((:SCIPcomputeLPRelIntPoint, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, Cdouble, Cint, Ptr{Ptr{SCIP_SOL}}), scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) +end + +function SCIPgetColRedcost(scip, col) + ccall((:SCIPgetColRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) +end + +function SCIPgetColFarkasCoef(scip, col) + ccall((:SCIPgetColFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) +end + +function SCIPmarkColNotRemovableLocal(scip, col) + ccall((:SCIPmarkColNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) +end + +function SCIPcreateRowCons(scip, row, conshdlr, name, len::Cint, cols, vals, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) + ccall((:SCIPcreateRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateRowSepa(scip, row, sepa, name, len::Cint, cols, vals, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) + ccall((:SCIPcreateRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_SEPA}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, sepa, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateRowUnspec(scip, row, name, len::Cint, cols, vals, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) + ccall((:SCIPcreateRowUnspec, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateRow(scip, row, name, len::Cint, cols, vals, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) + ccall((:SCIPcreateRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateEmptyRowCons(scip, row, conshdlr, name, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) + ccall((:SCIPcreateEmptyRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateEmptyRowSepa(scip, row, sepa, name, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) + ccall((:SCIPcreateEmptyRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_SEPA}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, sepa, name, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateEmptyRowUnspec(scip, row, name, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) + ccall((:SCIPcreateEmptyRowUnspec, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateEmptyRow(scip, row, name, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) + ccall((:SCIPcreateEmptyRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcaptureRow(scip, row) + ccall((:SCIPcaptureRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPreleaseRow(scip, row) + ccall((:SCIPreleaseRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}), scip, row) +end + +function SCIPchgRowLhs(scip, row, lhs::Cdouble) + ccall((:SCIPchgRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, lhs) +end + +function SCIPchgRowRhs(scip, row, rhs::Cdouble) + ccall((:SCIPchgRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, rhs) +end + +function SCIPcacheRowExtensions(scip, row) + ccall((:SCIPcacheRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPflushRowExtensions(scip, row) + ccall((:SCIPflushRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPaddVarToRow(scip, row, var, val::Cdouble) + ccall((:SCIPaddVarToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_VAR}, Cdouble), scip, row, var, val) +end + +function SCIPaddVarsToRow(scip, row, nvars::Cint, vars, vals) + ccall((:SCIPaddVarsToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, row, nvars, vars, vals) +end + +function SCIPaddVarsToRowSameCoef(scip, row, nvars::Cint, vars, val::Cdouble) + ccall((:SCIPaddVarsToRowSameCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Cdouble), scip, row, nvars, vars, val) +end + +function SCIPcalcRowIntegralScalar(scip, row, mindelta::Cdouble, maxdelta::Cdouble, maxdnom::Clonglong, maxscale::Cdouble, usecontvars::UInt32, intscalar, success) + ccall((:SCIPcalcRowIntegralScalar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Clonglong, Cdouble, UInt32, Ptr{Cdouble}, Ptr{UInt32}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) +end + +function SCIPmakeRowIntegral(scip, row, mindelta::Cdouble, maxdelta::Cdouble, maxdnom::Clonglong, maxscale::Cdouble, usecontvars::UInt32, success) + ccall((:SCIPmakeRowIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Clonglong, Cdouble, UInt32, Ptr{UInt32}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) +end + +function SCIPmarkRowNotRemovableLocal(scip, row) + ccall((:SCIPmarkRowNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowNumIntCols(scip, row) + ccall((:SCIPgetRowNumIntCols, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowMinCoef(scip, row) + ccall((:SCIPgetRowMinCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowMaxCoef(scip, row) + ccall((:SCIPgetRowMaxCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowMinActivity(scip, row) + ccall((:SCIPgetRowMinActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowMaxActivity(scip, row) + ccall((:SCIPgetRowMaxActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPrecalcRowLPActivity(scip, row) + ccall((:SCIPrecalcRowLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowLPActivity(scip, row) + ccall((:SCIPgetRowLPActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowLPFeasibility(scip, row) + ccall((:SCIPgetRowLPFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPrecalcRowPseudoActivity(scip, row) + ccall((:SCIPrecalcRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowPseudoActivity(scip, row) + ccall((:SCIPgetRowPseudoActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowPseudoFeasibility(scip, row) + ccall((:SCIPgetRowPseudoFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPrecalcRowActivity(scip, row) + ccall((:SCIPrecalcRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowActivity(scip, row) + ccall((:SCIPgetRowActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowFeasibility(scip, row) + ccall((:SCIPgetRowFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowSolActivity(scip, row, sol) + ccall((:SCIPgetRowSolActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) +end + +function SCIPgetRowSolFeasibility(scip, row, sol) + ccall((:SCIPgetRowSolFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) +end + +function SCIPprintRow(scip, row, file) + ccall((:SCIPprintRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{FILE}), scip, row, file) +end + +function SCIPstartDive(scip) + ccall((:SCIPstartDive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPendDive(scip) + ccall((:SCIPendDive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPchgCutoffboundDive(scip, newcutoffbound::Cdouble) + ccall((:SCIPchgCutoffboundDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newcutoffbound) +end + +function SCIPchgVarObjDive(scip, var, newobj::Cdouble) + ccall((:SCIPchgVarObjDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) +end + +function SCIPchgVarLbDive(scip, var, newbound::Cdouble) + ccall((:SCIPchgVarLbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPchgVarUbDive(scip, var, newbound::Cdouble) + ccall((:SCIPchgVarUbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPaddRowDive(scip, row) + ccall((:SCIPaddRowDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPchgRowLhsDive(scip, row, newlhs::Cdouble) + ccall((:SCIPchgRowLhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newlhs) +end + +function SCIPchgRowRhsDive(scip, row, newrhs::Cdouble) + ccall((:SCIPchgRowRhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newrhs) +end + +function SCIPgetVarObjDive(scip, var) + ccall((:SCIPgetVarObjDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarLbDive(scip, var) + ccall((:SCIPgetVarLbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarUbDive(scip, var) + ccall((:SCIPgetVarUbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPsolveDiveLP(scip, itlim::Cint, lperror, cutoff) + ccall((:SCIPsolveDiveLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, itlim, lperror, cutoff) +end + +function SCIPgetLastDivenode(scip) + ccall((:SCIPgetLastDivenode, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPinDive(scip) + ccall((:SCIPinDive, libscip), UInt32, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_mem.jl b/src/wrapper/scip_mem.jl new file mode 100644 index 00000000..83f0696a --- /dev/null +++ b/src/wrapper/scip_mem.jl @@ -0,0 +1,39 @@ +# Julia wrapper for header: /usr/include/scip/scip_mem.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPblkmem(scip) + ccall((:SCIPblkmem, libscip), Ptr{BMS_BLKMEM}, (Ptr{SCIP},), scip) +end + +function SCIPbuffer(scip) + ccall((:SCIPbuffer, libscip), Ptr{BMS_BUFMEM}, (Ptr{SCIP},), scip) +end + +function SCIPcleanbuffer(scip) + ccall((:SCIPcleanbuffer, libscip), Ptr{BMS_BUFMEM}, (Ptr{SCIP},), scip) +end + +function SCIPgetMemUsed(scip) + ccall((:SCIPgetMemUsed, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetMemTotal(scip) + ccall((:SCIPgetMemTotal, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetMemExternEstim(scip) + ccall((:SCIPgetMemExternEstim, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPcalcMemGrowSize(scip, num::Cint) + ccall((:SCIPcalcMemGrowSize, libscip), Cint, (Ptr{SCIP}, Cint), scip, num) +end + +function SCIPensureBlockMemoryArray_call(scip, arrayptr, elemsize::Csize_t, arraysize, minsize::Cint) + ccall((:SCIPensureBlockMemoryArray_call, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cint}, Cint), scip, arrayptr, elemsize, arraysize, minsize) +end + +function SCIPprintMemoryDiagnostic(scip) + ccall((:SCIPprintMemoryDiagnostic, libscip), Cvoid, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_message.jl b/src/wrapper/scip_message.jl new file mode 100644 index 00000000..66e5dac5 --- /dev/null +++ b/src/wrapper/scip_message.jl @@ -0,0 +1,23 @@ +# Julia wrapper for header: /usr/include/scip/scip_message.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPsetMessagehdlr(scip, messagehdlr) + ccall((:SCIPsetMessagehdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_MESSAGEHDLR}), scip, messagehdlr) +end + +function SCIPgetMessagehdlr(scip) + ccall((:SCIPgetMessagehdlr, libscip), Ptr{SCIP_MESSAGEHDLR}, (Ptr{SCIP},), scip) +end + +function SCIPsetMessagehdlrLogfile(scip, filename) + ccall((:SCIPsetMessagehdlrLogfile, libscip), Cvoid, (Ptr{SCIP}, Cstring), scip, filename) +end + +function SCIPsetMessagehdlrQuiet(scip, quiet::UInt32) + ccall((:SCIPsetMessagehdlrQuiet, libscip), Cvoid, (Ptr{SCIP}, UInt32), scip, quiet) +end + +function SCIPgetVerbLevel(scip) + ccall((:SCIPgetVerbLevel, libscip), SCIP_VERBLEVEL, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_nlp.jl b/src/wrapper/scip_nlp.jl new file mode 100644 index 00000000..f079f7c4 --- /dev/null +++ b/src/wrapper/scip_nlp.jl @@ -0,0 +1,303 @@ +# Julia wrapper for header: /usr/include/scip/scip_nlp.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeNlpi(scip, nlpi) + ccall((:SCIPincludeNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}), scip, nlpi) +end + +function SCIPfindNlpi(scip, name) + ccall((:SCIPfindNlpi, libscip), Ptr{SCIP_NLPI}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetNlpis(scip) + ccall((:SCIPgetNlpis, libscip), Ptr{Ptr{SCIP_NLPI}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNNlpis(scip) + ccall((:SCIPgetNNlpis, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetNlpiPriority(scip, nlpi, priority::Cint) + ccall((:SCIPsetNlpiPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Cint), scip, nlpi, priority) +end + +function SCIPisNLPEnabled(scip) + ccall((:SCIPisNLPEnabled, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPenableNLP(scip) + ccall((:SCIPenableNLP, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPisNLPConstructed(scip) + ccall((:SCIPisNLPConstructed, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPhasNLPContinuousNonlinearity(scip) + ccall((:SCIPhasNLPContinuousNonlinearity, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPVarsData(scip, vars, nvars) + ccall((:SCIPgetNLPVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}), scip, vars, nvars) +end + +function SCIPgetNLPVars(scip) + ccall((:SCIPgetNLPVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNNLPVars(scip) + ccall((:SCIPgetNNLPVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPVarsNonlinearity(scip, nlcount) + ccall((:SCIPgetNLPVarsNonlinearity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, nlcount) +end + +function SCIPgetNLPVarsLbDualsol(scip) + ccall((:SCIPgetNLPVarsLbDualsol, libscip), Ptr{Cdouble}, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPVarsUbDualsol(scip) + ccall((:SCIPgetNLPVarsUbDualsol, libscip), Ptr{Cdouble}, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPNlRowsData(scip, nlrows, nnlrows) + ccall((:SCIPgetNLPNlRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NLROW}}}, Ptr{Cint}), scip, nlrows, nnlrows) +end + +function SCIPgetNLPNlRows(scip) + ccall((:SCIPgetNLPNlRows, libscip), Ptr{Ptr{SCIP_NLROW}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNNLPNlRows(scip) + ccall((:SCIPgetNNLPNlRows, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPaddNlRow(scip, nlrow) + ccall((:SCIPaddNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) +end + +function SCIPflushNLP(scip) + ccall((:SCIPflushNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPsetNLPInitialGuess(scip, initialguess) + ccall((:SCIPsetNLPInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}), scip, initialguess) +end + +function SCIPsetNLPInitialGuessSol(scip, sol) + ccall((:SCIPsetNLPInitialGuessSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPsolveNLP(scip) + ccall((:SCIPsolveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPSolstat(scip) + ccall((:SCIPgetNLPSolstat, libscip), SCIP_NLPSOLSTAT, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPTermstat(scip) + ccall((:SCIPgetNLPTermstat, libscip), SCIP_NLPTERMSTAT, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPStatistics(scip, statistics) + ccall((:SCIPgetNLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPSTATISTICS}), scip, statistics) +end + +function SCIPgetNLPObjval(scip) + ccall((:SCIPgetNLPObjval, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPhasNLPSolution(scip) + ccall((:SCIPhasNLPSolution, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPFracVars(scip, fracvars, fracvarssol, fracvarsfrac, nfracvars, npriofracvars) + ccall((:SCIPgetNLPFracVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}), scip, fracvars, fracvarssol, fracvarsfrac, nfracvars, npriofracvars) +end + +function SCIPgetNLPIntPar(scip, _type::SCIP_NLPPARAM, ival) + ccall((:SCIPgetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cint}), scip, _type, ival) +end + +function SCIPsetNLPIntPar(scip, _type::SCIP_NLPPARAM, ival::Cint) + ccall((:SCIPsetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cint), scip, _type, ival) +end + +function SCIPgetNLPRealPar(scip, _type::SCIP_NLPPARAM, dval) + ccall((:SCIPgetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cdouble}), scip, _type, dval) +end + +function SCIPsetNLPRealPar(scip, _type::SCIP_NLPPARAM, dval::Cdouble) + ccall((:SCIPsetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cdouble), scip, _type, dval) +end + +function SCIPgetNLPStringPar(scip, _type::SCIP_NLPPARAM, sval) + ccall((:SCIPgetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cstring}), scip, _type, sval) +end + +function SCIPsetNLPStringPar(scip, _type::SCIP_NLPPARAM, sval) + ccall((:SCIPsetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cstring), scip, _type, sval) +end + +function SCIPwriteNLP(scip, filename) + ccall((:SCIPwriteNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) +end + +function SCIPgetNLPI(scip, nlpi, nlpiproblem) + ccall((:SCIPgetNLPI, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLPI}}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), scip, nlpi, nlpiproblem) +end + +function SCIPstartDiveNLP(scip) + ccall((:SCIPstartDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPendDiveNLP(scip) + ccall((:SCIPendDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPchgVarObjDiveNLP(scip, var, coef::Cdouble) + ccall((:SCIPchgVarObjDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, coef) +end + +function SCIPchgVarBoundsDiveNLP(scip, var, lb::Cdouble, ub::Cdouble) + ccall((:SCIPchgVarBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, lb, ub) +end + +function SCIPchgVarsBoundsDiveNLP(scip, nvars::Cint, vars, lbs, ubs) + ccall((:SCIPchgVarsBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nvars, vars, lbs, ubs) +end + +function SCIPsolveDiveNLP(scip) + ccall((:SCIPsolveDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateNlRow(scip, nlrow, name, constant::Cdouble, nlinvars::Cint, linvars, lincoefs, nquadvars::Cint, quadvars, nquadelems::Cint, quadelems, expression, lhs::Cdouble, rhs::Cdouble, curvature::SCIP_EXPRCURV) + ccall((:SCIPcreateNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Cstring, Cdouble, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{SCIP_QUADELEM}, Ptr{SCIP_EXPRTREE}, Cdouble, Cdouble, SCIP_EXPRCURV), scip, nlrow, name, constant, nlinvars, linvars, lincoefs, nquadvars, quadvars, nquadelems, quadelems, expression, lhs, rhs, curvature) +end + +function SCIPcreateEmptyNlRow(scip, nlrow, name, lhs::Cdouble, rhs::Cdouble) + ccall((:SCIPcreateEmptyNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Cstring, Cdouble, Cdouble), scip, nlrow, name, lhs, rhs) +end + +function SCIPcreateNlRowFromRow(scip, nlrow, row) + ccall((:SCIPcreateNlRowFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{SCIP_ROW}), scip, nlrow, row) +end + +function SCIPcaptureNlRow(scip, nlrow) + ccall((:SCIPcaptureNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) +end + +function SCIPreleaseNlRow(scip, nlrow) + ccall((:SCIPreleaseNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}), scip, nlrow) +end + +function SCIPchgNlRowLhs(scip, nlrow, lhs::Cdouble) + ccall((:SCIPchgNlRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, lhs) +end + +function SCIPchgNlRowRhs(scip, nlrow, rhs::Cdouble) + ccall((:SCIPchgNlRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, rhs) +end + +function SCIPchgNlRowConstant(scip, nlrow, constant::Cdouble) + ccall((:SCIPchgNlRowConstant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, constant) +end + +function SCIPaddLinearCoefToNlRow(scip, nlrow, var, val::Cdouble) + ccall((:SCIPaddLinearCoefToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, val) +end + +function SCIPaddLinearCoefsToNlRow(scip, nlrow, nvars::Cint, vars, vals) + ccall((:SCIPaddLinearCoefsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nlrow, nvars, vars, vals) +end + +function SCIPchgNlRowLinearCoef(scip, nlrow, var, coef::Cdouble) + ccall((:SCIPchgNlRowLinearCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, coef) +end + +function SCIPaddQuadVarToNlRow(scip, nlrow, var) + ccall((:SCIPaddQuadVarToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}), scip, nlrow, var) +end + +function SCIPaddQuadVarsToNlRow(scip, nlrow, nvars::Cint, vars) + ccall((:SCIPaddQuadVarsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, nlrow, nvars, vars) +end + +function SCIPaddQuadElementToNlRow(scip, nlrow, quadelem::SCIP_QUADELEM) + ccall((:SCIPaddQuadElementToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_QUADELEM), scip, nlrow, quadelem) +end + +function SCIPaddQuadElementsToNlRow(scip, nlrow, nquadelems::Cint, quadelems) + ccall((:SCIPaddQuadElementsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{SCIP_QUADELEM}), scip, nlrow, nquadelems, quadelems) +end + +function SCIPchgNlRowQuadElement(scip, nlrow, quadelement::SCIP_QUADELEM) + ccall((:SCIPchgNlRowQuadElement, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_QUADELEM), scip, nlrow, quadelement) +end + +function SCIPsetNlRowExprtree(scip, nlrow, exprtree) + ccall((:SCIPsetNlRowExprtree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_EXPRTREE}), scip, nlrow, exprtree) +end + +function SCIPsetNlRowExprtreeParam(scip, nlrow, paramidx::Cint, paramval::Cdouble) + ccall((:SCIPsetNlRowExprtreeParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Cdouble), scip, nlrow, paramidx, paramval) +end + +function SCIPsetNlRowExprtreeParams(scip, nlrow, paramvals) + ccall((:SCIPsetNlRowExprtreeParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, paramvals) +end + +function SCIPrecalcNlRowNLPActivity(scip, nlrow) + ccall((:SCIPrecalcNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) +end + +function SCIPgetNlRowNLPActivity(scip, nlrow, activity) + ccall((:SCIPgetNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) +end + +function SCIPgetNlRowNLPFeasibility(scip, nlrow, feasibility) + ccall((:SCIPgetNlRowNLPFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) +end + +function SCIPrecalcNlRowPseudoActivity(scip, nlrow) + ccall((:SCIPrecalcNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) +end + +function SCIPgetNlRowPseudoActivity(scip, nlrow, pseudoactivity) + ccall((:SCIPgetNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudoactivity) +end + +function SCIPgetNlRowPseudoFeasibility(scip, nlrow, pseudofeasibility) + ccall((:SCIPgetNlRowPseudoFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudofeasibility) +end + +function SCIPrecalcNlRowActivity(scip, nlrow) + ccall((:SCIPrecalcNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) +end + +function SCIPgetNlRowActivity(scip, nlrow, activity) + ccall((:SCIPgetNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) +end + +function SCIPgetNlRowFeasibility(scip, nlrow, feasibility) + ccall((:SCIPgetNlRowFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) +end + +function SCIPgetNlRowSolActivity(scip, nlrow, sol, activity) + ccall((:SCIPgetNlRowSolActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, activity) +end + +function SCIPgetNlRowSolFeasibility(scip, nlrow, sol, feasibility) + ccall((:SCIPgetNlRowSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, feasibility) +end + +function SCIPgetNlRowActivityBounds(scip, nlrow, minactivity, maxactivity) + ccall((:SCIPgetNlRowActivityBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlrow, minactivity, maxactivity) +end + +function SCIPprintNlRow(scip, nlrow, file) + ccall((:SCIPprintNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{FILE}), scip, nlrow, file) +end diff --git a/src/wrapper/scip_nodesel.jl b/src/wrapper/scip_nodesel.jl new file mode 100644 index 00000000..11ed2417 --- /dev/null +++ b/src/wrapper/scip_nodesel.jl @@ -0,0 +1,59 @@ +# Julia wrapper for header: /usr/include/scip/scip_nodesel.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeNodesel(scip, name, desc, stdpriority::Cint, memsavepriority::Cint, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) + ccall((:SCIPincludeNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) +end + +function SCIPincludeNodeselBasic(scip, nodesel, name, desc, stdpriority::Cint, memsavepriority::Cint, nodeselselect, nodeselcomp, nodeseldata) + ccall((:SCIPincludeNodeselBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NODESEL}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, nodesel, name, desc, stdpriority, memsavepriority, nodeselselect, nodeselcomp, nodeseldata) +end + +function SCIPsetNodeselCopy(scip, nodesel, nodeselcopy) + ccall((:SCIPsetNodeselCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselcopy) +end + +function SCIPsetNodeselFree(scip, nodesel, nodeselfree) + ccall((:SCIPsetNodeselFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselfree) +end + +function SCIPsetNodeselInit(scip, nodesel, nodeselinit) + ccall((:SCIPsetNodeselInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinit) +end + +function SCIPsetNodeselExit(scip, nodesel, nodeselexit) + ccall((:SCIPsetNodeselExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexit) +end + +function SCIPsetNodeselInitsol(scip, nodesel, nodeselinitsol) + ccall((:SCIPsetNodeselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinitsol) +end + +function SCIPsetNodeselExitsol(scip, nodesel, nodeselexitsol) + ccall((:SCIPsetNodeselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexitsol) +end + +function SCIPfindNodesel(scip, name) + ccall((:SCIPfindNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetNodesels(scip) + ccall((:SCIPgetNodesels, libscip), Ptr{Ptr{SCIP_NODESEL}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNNodesels(scip) + ccall((:SCIPgetNNodesels, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetNodeselStdPriority(scip, nodesel, priority::Cint) + ccall((:SCIPsetNodeselStdPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) +end + +function SCIPsetNodeselMemsavePriority(scip, nodesel, priority::Cint) + ccall((:SCIPsetNodeselMemsavePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) +end + +function SCIPgetNodesel(scip) + ccall((:SCIPgetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_nonlinear.jl b/src/wrapper/scip_nonlinear.jl new file mode 100644 index 00000000..97d5e0df --- /dev/null +++ b/src/wrapper/scip_nonlinear.jl @@ -0,0 +1,39 @@ +# Julia wrapper for header: /usr/include/scip/scip_nonlinear.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPaddSquareLinearization(scip, sqrcoef::Cdouble, refpoint::Cdouble, isint::UInt32, lincoef, linconstant, success) + ccall((:SCIPaddSquareLinearization, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, UInt32, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) +end + +function SCIPaddSquareSecant(scip, sqrcoef::Cdouble, lb::Cdouble, ub::Cdouble, refpoint::Cdouble, lincoef, linconstant, success) + ccall((:SCIPaddSquareSecant, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, sqrcoef, lb, ub, refpoint, lincoef, linconstant, success) +end + +function SCIPaddBilinLinearization(scip, bilincoef::Cdouble, refpointx::Cdouble, refpointy::Cdouble, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPaddBilinLinearization, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, refpointx, refpointy, lincoefx, lincoefy, linconstant, success) +end + +function SCIPaddBilinMcCormick(scip, bilincoef::Cdouble, lbx::Cdouble, ubx::Cdouble, refpointx::Cdouble, lby::Cdouble, uby::Cdouble, refpointy::Cdouble, overestimate::UInt32, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPaddBilinMcCormick, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, lincoefx, lincoefy, linconstant, success) +end + +function SCIPcomputeBilinEnvelope1(scip, bilincoef::Cdouble, lbx::Cdouble, ubx::Cdouble, refpointx::Cdouble, lby::Cdouble, uby::Cdouble, refpointy::Cdouble, overestimate::UInt32, xcoef::Cdouble, ycoef::Cdouble, constant::Cdouble, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPcomputeBilinEnvelope1, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, xcoef, ycoef, constant, lincoefx, lincoefy, linconstant, success) +end + +function SCIPcomputeBilinEnvelope2(scip, bilincoef::Cdouble, lbx::Cdouble, ubx::Cdouble, refpointx::Cdouble, lby::Cdouble, uby::Cdouble, refpointy::Cdouble, overestimate::UInt32, alpha1::Cdouble, beta1::Cdouble, gamma1::Cdouble, alpha2::Cdouble, beta2::Cdouble, gamma2::Cdouble, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPcomputeBilinEnvelope2, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, alpha1, beta1, gamma1, alpha2, beta2, gamma2, lincoefx, lincoefy, linconstant, success) +end + +function SCIPcreateNlpiProb(scip, nlpi, nlrows, nnlrows::Cint, nlpiprob, var2idx, nlscore, cutoffbound::Cdouble, setobj::UInt32, onlyconvex::UInt32) + ccall((:SCIPcreateNlpiProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLROW}}, Cint, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Cdouble}, Cdouble, UInt32, UInt32), scip, nlpi, nlrows, nnlrows, nlpiprob, var2idx, nlscore, cutoffbound, setobj, onlyconvex) +end + +function SCIPupdateNlpiProb(scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars::Cint, cutoffbound::Cdouble) + ccall((:SCIPupdateNlpiProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cdouble), scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) +end + +function SCIPaddNlpiProbRows(scip, nlpi, nlpiprob, var2idx, rows, nrows::Cint) + ccall((:SCIPaddNlpiProbRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_ROW}}, Cint), scip, nlpi, nlpiprob, var2idx, rows, nrows) +end diff --git a/src/wrapper/scip_numerics.jl b/src/wrapper/scip_numerics.jl new file mode 100644 index 00000000..a3612728 --- /dev/null +++ b/src/wrapper/scip_numerics.jl @@ -0,0 +1,347 @@ +# Julia wrapper for header: /usr/include/scip/scip_numerics.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPepsilon(scip) + ccall((:SCIPepsilon, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPsumepsilon(scip) + ccall((:SCIPsumepsilon, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPfeastol(scip) + ccall((:SCIPfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPlpfeastol(scip) + ccall((:SCIPlpfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPdualfeastol(scip) + ccall((:SCIPdualfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPbarrierconvtol(scip) + ccall((:SCIPbarrierconvtol, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPcutoffbounddelta(scip) + ccall((:SCIPcutoffbounddelta, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPrelaxfeastol(scip) + ccall((:SCIPrelaxfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPchgFeastol(scip, feastol::Cdouble) + ccall((:SCIPchgFeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, feastol) +end + +function SCIPchgLpfeastol(scip, lpfeastol::Cdouble, printnewvalue::UInt32) + ccall((:SCIPchgLpfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, UInt32), scip, lpfeastol, printnewvalue) +end + +function SCIPchgDualfeastol(scip, dualfeastol::Cdouble) + ccall((:SCIPchgDualfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, dualfeastol) +end + +function SCIPchgBarrierconvtol(scip, barrierconvtol::Cdouble) + ccall((:SCIPchgBarrierconvtol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, barrierconvtol) +end + +function SCIPchgRelaxfeastol(scip, relaxfeastol::Cdouble) + ccall((:SCIPchgRelaxfeastol, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, relaxfeastol) +end + +function SCIPmarkLimitChanged(scip) + ccall((:SCIPmarkLimitChanged, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPinfinity(scip) + ccall((:SCIPinfinity, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetHugeValue(scip) + ccall((:SCIPgetHugeValue, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPisEQ(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisLT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisLE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisGT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisGE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisInfinity(scip, val::Cdouble) + ccall((:SCIPisInfinity, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisHugeValue(scip, val::Cdouble) + ccall((:SCIPisHugeValue, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisZero(scip, val::Cdouble) + ccall((:SCIPisZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisPositive(scip, val::Cdouble) + ccall((:SCIPisPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisNegative(scip, val::Cdouble) + ccall((:SCIPisNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisIntegral(scip, val::Cdouble) + ccall((:SCIPisIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisScalingIntegral(scip, val::Cdouble, scalar::Cdouble) + ccall((:SCIPisScalingIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val, scalar) +end + +function SCIPisFracIntegral(scip, val::Cdouble) + ccall((:SCIPisFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPfloor(scip, val::Cdouble) + ccall((:SCIPfloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPceil(scip, val::Cdouble) + ccall((:SCIPceil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPround(scip, val::Cdouble) + ccall((:SCIPround, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPfrac(scip, val::Cdouble) + ccall((:SCIPfrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisSumEQ(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumLT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumLE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumGT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumGE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumZero(scip, val::Cdouble) + ccall((:SCIPisSumZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisSumPositive(scip, val::Cdouble) + ccall((:SCIPisSumPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisSumNegative(scip, val::Cdouble) + ccall((:SCIPisSumNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisFeasEQ(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisFeasEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisFeasLT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisFeasLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisFeasLE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisFeasLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisFeasGT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisFeasGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisFeasGE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisFeasGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisFeasZero(scip, val::Cdouble) + ccall((:SCIPisFeasZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisFeasPositive(scip, val::Cdouble) + ccall((:SCIPisFeasPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisFeasNegative(scip, val::Cdouble) + ccall((:SCIPisFeasNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisFeasIntegral(scip, val::Cdouble) + ccall((:SCIPisFeasIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisFeasFracIntegral(scip, val::Cdouble) + ccall((:SCIPisFeasFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPfeasFloor(scip, val::Cdouble) + ccall((:SCIPfeasFloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPfeasCeil(scip, val::Cdouble) + ccall((:SCIPfeasCeil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPfeasRound(scip, val::Cdouble) + ccall((:SCIPfeasRound, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPfeasFrac(scip, val::Cdouble) + ccall((:SCIPfeasFrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisDualfeasEQ(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisDualfeasEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisDualfeasLT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisDualfeasLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisDualfeasLE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisDualfeasLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisDualfeasGT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisDualfeasGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisDualfeasGE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisDualfeasGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisDualfeasZero(scip, val::Cdouble) + ccall((:SCIPisDualfeasZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisDualfeasPositive(scip, val::Cdouble) + ccall((:SCIPisDualfeasPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisDualfeasNegative(scip, val::Cdouble) + ccall((:SCIPisDualfeasNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisDualfeasIntegral(scip, val::Cdouble) + ccall((:SCIPisDualfeasIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisDualfeasFracIntegral(scip, val::Cdouble) + ccall((:SCIPisDualfeasFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPdualfeasFloor(scip, val::Cdouble) + ccall((:SCIPdualfeasFloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPdualfeasCeil(scip, val::Cdouble) + ccall((:SCIPdualfeasCeil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPdualfeasRound(scip, val::Cdouble) + ccall((:SCIPdualfeasRound, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPdualfeasFrac(scip, val::Cdouble) + ccall((:SCIPdualfeasFrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) +end + +function SCIPisLbBetter(scip, newlb::Cdouble, oldlb::Cdouble, oldub::Cdouble) + ccall((:SCIPisLbBetter, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newlb, oldlb, oldub) +end + +function SCIPisUbBetter(scip, newub::Cdouble, oldlb::Cdouble, oldub::Cdouble) + ccall((:SCIPisUbBetter, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newub, oldlb, oldub) +end + +function SCIPisRelEQ(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisRelEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisRelLT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisRelLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisRelLE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisRelLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisRelGT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisRelGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisRelGE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisRelGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumRelEQ(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumRelEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumRelLT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumRelLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumRelLE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumRelLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumRelGT(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumRelGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPisSumRelGE(scip, val1::Cdouble, val2::Cdouble) + ccall((:SCIPisSumRelGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPconvertRealToInt(scip, real::Cdouble) + ccall((:SCIPconvertRealToInt, libscip), Cint, (Ptr{SCIP}, Cdouble), scip, real) +end + +function SCIPconvertRealToLongint(scip, real::Cdouble) + ccall((:SCIPconvertRealToLongint, libscip), Clonglong, (Ptr{SCIP}, Cdouble), scip, real) +end + +function SCIPisUpdateUnreliable(scip, newvalue::Cdouble, oldvalue::Cdouble) + ccall((:SCIPisUpdateUnreliable, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, newvalue, oldvalue) +end + +function SCIPprintReal(scip, file, val::Cdouble, width::Cint, precision::Cint) + ccall((:SCIPprintReal, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}, Cdouble, Cint, Cint), scip, file, val, width, precision) +end + +function SCIPparseReal(scip, str, value, endptr) + ccall((:SCIPparseReal, libscip), UInt32, (Ptr{SCIP}, Cstring, Ptr{Cdouble}, Ptr{Cstring}), scip, str, value, endptr) +end diff --git a/src/wrapper/scip_param.jl b/src/wrapper/scip_param.jl new file mode 100644 index 00000000..83464d27 --- /dev/null +++ b/src/wrapper/scip_param.jl @@ -0,0 +1,191 @@ +# Julia wrapper for header: /usr/include/scip/scip_param.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPaddBoolParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::UInt32, paramchgd, paramdata) + ccall((:SCIPaddBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{UInt32}, UInt32, UInt32, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) +end + +function SCIPaddIntParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::Cint, minvalue::Cint, maxvalue::Cint, paramchgd, paramdata) + ccall((:SCIPaddIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cint}, UInt32, Cint, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) +end + +function SCIPaddLongintParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::Clonglong, minvalue::Clonglong, maxvalue::Clonglong, paramchgd, paramdata) + ccall((:SCIPaddLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Clonglong}, UInt32, Clonglong, Clonglong, Clonglong, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) +end + +function SCIPaddRealParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::Cdouble, minvalue::Cdouble, maxvalue::Cdouble, paramchgd, paramdata) + ccall((:SCIPaddRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cdouble}, UInt32, Cdouble, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) +end + +function SCIPaddCharParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::UInt8, allowedvalues, paramchgd, paramdata) + ccall((:SCIPaddCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cstring, UInt32, UInt8, Cstring, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) +end + +function SCIPaddStringParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue, paramchgd, paramdata) + ccall((:SCIPaddStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cstring}, UInt32, Cstring, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) +end + +function SCIPisParamFixed(scip, name) + ccall((:SCIPisParamFixed, libscip), UInt32, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetParam(scip, name) + ccall((:SCIPgetParam, libscip), Ptr{SCIP_PARAM}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetBoolParam(scip, name, value) + ccall((:SCIPgetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{UInt32}), scip, name, value) +end + +function SCIPgetIntParam(scip, name, value) + ccall((:SCIPgetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cint}), scip, name, value) +end + +function SCIPgetLongintParam(scip, name, value) + ccall((:SCIPgetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Clonglong}), scip, name, value) +end + +function SCIPgetRealParam(scip, name, value) + ccall((:SCIPgetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cdouble}), scip, name, value) +end + +function SCIPgetCharParam(scip, name, value) + ccall((:SCIPgetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, name, value) +end + +function SCIPgetStringParam(scip, name, value) + ccall((:SCIPgetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cstring}), scip, name, value) +end + +function SCIPfixParam(scip, name) + ccall((:SCIPfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPunfixParam(scip, name) + ccall((:SCIPunfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPsetParam(scip, name, value) + ccall((:SCIPsetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cvoid}), scip, name, value) +end + +function SCIPchgBoolParam(scip, param, value::UInt32) + ccall((:SCIPchgBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt32), scip, param, value) +end + +function SCIPsetBoolParam(scip, name, value::UInt32) + ccall((:SCIPsetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32), scip, name, value) +end + +function SCIPisBoolParamValid(scip, param, value::UInt32) + ccall((:SCIPisBoolParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt32), scip, param, value) +end + +function SCIPchgIntParam(scip, param, value::Cint) + ccall((:SCIPchgIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) +end + +function SCIPsetIntParam(scip, name, value::Cint) + ccall((:SCIPsetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cint), scip, name, value) +end + +function SCIPisIntParamValid(scip, param, value::Cint) + ccall((:SCIPisIntParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) +end + +function SCIPchgLongintParam(scip, param, value::Clonglong) + ccall((:SCIPchgLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) +end + +function SCIPsetLongintParam(scip, name, value::Clonglong) + ccall((:SCIPsetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Clonglong), scip, name, value) +end + +function SCIPisLongintParamValid(scip, param, value::Clonglong) + ccall((:SCIPisLongintParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) +end + +function SCIPchgRealParam(scip, param, value::Cdouble) + ccall((:SCIPchgRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) +end + +function SCIPsetRealParam(scip, name, value::Cdouble) + ccall((:SCIPsetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cdouble), scip, name, value) +end + +function SCIPisRealParamValid(scip, param, value::Cdouble) + ccall((:SCIPisRealParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) +end + +function SCIPchgCharParam(scip, param, value::UInt8) + ccall((:SCIPchgCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt8), scip, param, value) +end + +function SCIPsetCharParam(scip, name, value::UInt8) + ccall((:SCIPsetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt8), scip, name, value) +end + +function SCIPisCharParamValid(scip, param, value::UInt8) + ccall((:SCIPisCharParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt8), scip, param, value) +end + +function SCIPchgStringParam(scip, param, value) + ccall((:SCIPchgStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cstring), scip, param, value) +end + +function SCIPsetStringParam(scip, name, value) + ccall((:SCIPsetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, name, value) +end + +function SCIPisStringParamValid(scip, param, value) + ccall((:SCIPisStringParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cstring), scip, param, value) +end + +function SCIPreadParams(scip, filename) + ccall((:SCIPreadParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) +end + +function SCIPwriteParam(scip, param, filename, comments::UInt32, onlychanged::UInt32) + ccall((:SCIPwriteParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cstring, UInt32, UInt32), scip, param, filename, comments, onlychanged) +end + +function SCIPwriteParams(scip, filename, comments::UInt32, onlychanged::UInt32) + ccall((:SCIPwriteParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32, UInt32), scip, filename, comments, onlychanged) +end + +function SCIPresetParam(scip, name) + ccall((:SCIPresetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPresetParams(scip) + ccall((:SCIPresetParams, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPsetEmphasis(scip, paramemphasis::SCIP_PARAMEMPHASIS, quiet::UInt32) + ccall((:SCIPsetEmphasis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMEMPHASIS, UInt32), scip, paramemphasis, quiet) +end + +function SCIPsetSubscipsOff(scip, quiet::UInt32) + ccall((:SCIPsetSubscipsOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, quiet) +end + +function SCIPsetHeuristics(scip, paramsetting::SCIP_PARAMSETTING, quiet::UInt32) + ccall((:SCIPsetHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) +end + +function SCIPsetPresolving(scip, paramsetting::SCIP_PARAMSETTING, quiet::UInt32) + ccall((:SCIPsetPresolving, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) +end + +function SCIPsetSeparating(scip, paramsetting::SCIP_PARAMSETTING, quiet::UInt32) + ccall((:SCIPsetSeparating, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) +end + +function SCIPgetParams(scip) + ccall((:SCIPgetParams, libscip), Ptr{Ptr{SCIP_PARAM}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNParams(scip) + ccall((:SCIPgetNParams, libscip), Cint, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_presol.jl b/src/wrapper/scip_presol.jl new file mode 100644 index 00000000..625bd581 --- /dev/null +++ b/src/wrapper/scip_presol.jl @@ -0,0 +1,51 @@ +# Julia wrapper for header: /usr/include/scip/scip_presol.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludePresol(scip, name, desc, priority::Cint, maxrounds::Cint, timing::SCIP_PRESOLTIMING, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) + ccall((:SCIPincludePresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, name, desc, priority, maxrounds, timing, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) +end + +function SCIPincludePresolBasic(scip, presolptr, name, desc, priority::Cint, maxrounds::Cint, timing::SCIP_PRESOLTIMING, presolexec, presoldata) + ccall((:SCIPincludePresolBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PRESOL}}, Cstring, Cstring, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, presolptr, name, desc, priority, maxrounds, timing, presolexec, presoldata) +end + +function SCIPsetPresolCopy(scip, presol, presolcopy) + ccall((:SCIPsetPresolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolcopy) +end + +function SCIPsetPresolFree(scip, presol, presolfree) + ccall((:SCIPsetPresolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolfree) +end + +function SCIPsetPresolInit(scip, presol, presolinit) + ccall((:SCIPsetPresolInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinit) +end + +function SCIPsetPresolExit(scip, presol, presolexit) + ccall((:SCIPsetPresolExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexit) +end + +function SCIPsetPresolInitpre(scip, presol, presolinitpre) + ccall((:SCIPsetPresolInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinitpre) +end + +function SCIPsetPresolExitpre(scip, presol, presolexitpre) + ccall((:SCIPsetPresolExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexitpre) +end + +function SCIPfindPresol(scip, name) + ccall((:SCIPfindPresol, libscip), Ptr{SCIP_PRESOL}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetPresols(scip) + ccall((:SCIPgetPresols, libscip), Ptr{Ptr{SCIP_PRESOL}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNPresols(scip) + ccall((:SCIPgetNPresols, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetPresolPriority(scip, presol, priority::Cint) + ccall((:SCIPsetPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Cint), scip, presol, priority) +end diff --git a/src/wrapper/scip_pricer.jl b/src/wrapper/scip_pricer.jl new file mode 100644 index 00000000..45303698 --- /dev/null +++ b/src/wrapper/scip_pricer.jl @@ -0,0 +1,63 @@ +# Julia wrapper for header: /usr/include/scip/scip_pricer.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludePricer(scip, name, desc, priority::Cint, delay::UInt32, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) + ccall((:SCIPincludePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, name, desc, priority, delay, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) +end + +function SCIPincludePricerBasic(scip, pricerptr, name, desc, priority::Cint, delay::UInt32, pricerredcost, pricerfarkas, pricerdata) + ccall((:SCIPincludePricerBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PRICER}}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, pricerptr, name, desc, priority, delay, pricerredcost, pricerfarkas, pricerdata) +end + +function SCIPsetPricerCopy(scip, pricer, pricercopy) + ccall((:SCIPsetPricerCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricercopy) +end + +function SCIPsetPricerFree(scip, pricer, pricerfree) + ccall((:SCIPsetPricerFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerfree) +end + +function SCIPsetPricerInit(scip, pricer, pricerinit) + ccall((:SCIPsetPricerInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinit) +end + +function SCIPsetPricerExit(scip, pricer, pricerexit) + ccall((:SCIPsetPricerExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexit) +end + +function SCIPsetPricerInitsol(scip, pricer, pricerinitsol) + ccall((:SCIPsetPricerInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinitsol) +end + +function SCIPsetPricerExitsol(scip, pricer, pricerexitsol) + ccall((:SCIPsetPricerExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexitsol) +end + +function SCIPfindPricer(scip, name) + ccall((:SCIPfindPricer, libscip), Ptr{SCIP_PRICER}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetPricers(scip) + ccall((:SCIPgetPricers, libscip), Ptr{Ptr{SCIP_PRICER}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNPricers(scip) + ccall((:SCIPgetNPricers, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNActivePricers(scip) + ccall((:SCIPgetNActivePricers, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetPricerPriority(scip, pricer, priority::Cint) + ccall((:SCIPsetPricerPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Cint), scip, pricer, priority) +end + +function SCIPactivatePricer(scip, pricer) + ccall((:SCIPactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}), scip, pricer) +end + +function SCIPdeactivatePricer(scip, pricer) + ccall((:SCIPdeactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}), scip, pricer) +end diff --git a/src/wrapper/scip_prob.jl b/src/wrapper/scip_prob.jl new file mode 100644 index 00000000..3612d925 --- /dev/null +++ b/src/wrapper/scip_prob.jl @@ -0,0 +1,331 @@ +# Julia wrapper for header: /usr/include/scip/scip_prob.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPcreateProb(scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) + ccall((:SCIPcreateProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PROBDATA}), scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) +end + +function SCIPcreateProbBasic(scip, name) + ccall((:SCIPcreateProbBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPsetProbDelorig(scip, probdelorig) + ccall((:SCIPsetProbDelorig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probdelorig) +end + +function SCIPsetProbTrans(scip, probtrans) + ccall((:SCIPsetProbTrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probtrans) +end + +function SCIPsetProbDeltrans(scip, probdeltrans) + ccall((:SCIPsetProbDeltrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probdeltrans) +end + +function SCIPsetProbInitsol(scip, probinitsol) + ccall((:SCIPsetProbInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probinitsol) +end + +function SCIPsetProbExitsol(scip, probexitsol) + ccall((:SCIPsetProbExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probexitsol) +end + +function SCIPsetProbCopy(scip, probcopy) + ccall((:SCIPsetProbCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probcopy) +end + +function SCIPreadProb(scip, filename, extension) + ccall((:SCIPreadProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, filename, extension) +end + +function SCIPwriteOrigProblem(scip, filename, extension, genericnames::UInt32) + ccall((:SCIPwriteOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32), scip, filename, extension, genericnames) +end + +function SCIPwriteTransProblem(scip, filename, extension, genericnames::UInt32) + ccall((:SCIPwriteTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32), scip, filename, extension, genericnames) +end + +function SCIPfreeProb(scip) + ccall((:SCIPfreeProb, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPpermuteProb(scip, randseed::UInt32, permuteconss::UInt32, permutebinvars::UInt32, permuteintvars::UInt32, permuteimplvars::UInt32, permutecontvars::UInt32) + ccall((:SCIPpermuteProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, randseed, permuteconss, permutebinvars, permuteintvars, permuteimplvars, permutecontvars) +end + +function SCIPgetProbData(scip) + ccall((:SCIPgetProbData, libscip), Ptr{SCIP_PROBDATA}, (Ptr{SCIP},), scip) +end + +function SCIPsetProbData(scip, probdata) + ccall((:SCIPsetProbData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROBDATA}), scip, probdata) +end + +function SCIPgetProbName(scip) + ccall((:SCIPgetProbName, libscip), Cstring, (Ptr{SCIP},), scip) +end + +function SCIPsetProbName(scip, name) + ccall((:SCIPsetProbName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPchgReoptObjective(scip, objsense::SCIP_OBJSENSE, vars, coefs, nvars::Cint) + ccall((:SCIPchgReoptObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), scip, objsense, vars, coefs, nvars) +end + +function SCIPgetObjsense(scip) + ccall((:SCIPgetObjsense, libscip), SCIP_OBJSENSE, (Ptr{SCIP},), scip) +end + +function SCIPsetObjsense(scip, objsense::SCIP_OBJSENSE) + ccall((:SCIPsetObjsense, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE), scip, objsense) +end + +function SCIPaddObjoffset(scip, addval::Cdouble) + ccall((:SCIPaddObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) +end + +function SCIPaddOrigObjoffset(scip, addval::Cdouble) + ccall((:SCIPaddOrigObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) +end + +function SCIPgetOrigObjoffset(scip) + ccall((:SCIPgetOrigObjoffset, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetOrigObjscale(scip) + ccall((:SCIPgetOrigObjscale, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetTransObjoffset(scip) + ccall((:SCIPgetTransObjoffset, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetTransObjscale(scip) + ccall((:SCIPgetTransObjscale, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPsetObjlimit(scip, objlimit::Cdouble) + ccall((:SCIPsetObjlimit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, objlimit) +end + +function SCIPgetObjlimit(scip) + ccall((:SCIPgetObjlimit, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPsetObjIntegral(scip) + ccall((:SCIPsetObjIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPisObjIntegral(scip) + ccall((:SCIPisObjIntegral, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetObjNorm(scip) + ccall((:SCIPgetObjNorm, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPaddVar(scip, var) + ccall((:SCIPaddVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPaddPricedVar(scip, var, score::Cdouble) + ccall((:SCIPaddPricedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, score) +end + +function SCIPdelVar(scip, var, deleted) + ccall((:SCIPdelVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{UInt32}), scip, var, deleted) +end + +function SCIPgetVarsData(scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) + ccall((:SCIPgetVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) +end + +function SCIPgetVars(scip) + ccall((:SCIPgetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNVars(scip) + ccall((:SCIPgetNVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNBinVars(scip) + ccall((:SCIPgetNBinVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNIntVars(scip) + ccall((:SCIPgetNIntVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNImplVars(scip) + ccall((:SCIPgetNImplVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNContVars(scip) + ccall((:SCIPgetNContVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNObjVars(scip) + ccall((:SCIPgetNObjVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetFixedVars(scip) + ccall((:SCIPgetFixedVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNFixedVars(scip) + ccall((:SCIPgetNFixedVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetOrigVarsData(scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) + ccall((:SCIPgetOrigVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) +end + +function SCIPgetOrigVars(scip) + ccall((:SCIPgetOrigVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNOrigVars(scip) + ccall((:SCIPgetNOrigVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNOrigBinVars(scip) + ccall((:SCIPgetNOrigBinVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNOrigIntVars(scip) + ccall((:SCIPgetNOrigIntVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNOrigImplVars(scip) + ccall((:SCIPgetNOrigImplVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNOrigContVars(scip) + ccall((:SCIPgetNOrigContVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNTotalVars(scip) + ccall((:SCIPgetNTotalVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetSolVarsData(scip, sol, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) + ccall((:SCIPgetSolVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, sol, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) +end + +function SCIPfindVar(scip, name) + ccall((:SCIPfindVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPallVarsInProb(scip) + ccall((:SCIPallVarsInProb, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPaddCons(scip, cons) + ccall((:SCIPaddCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPdelCons(scip, cons) + ccall((:SCIPdelCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPfindOrigCons(scip, name) + ccall((:SCIPfindOrigCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPfindCons(scip, name) + ccall((:SCIPfindCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetNUpgrConss(scip) + ccall((:SCIPgetNUpgrConss, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNConss(scip) + ccall((:SCIPgetNConss, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetConss(scip) + ccall((:SCIPgetConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNOrigConss(scip) + ccall((:SCIPgetNOrigConss, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetOrigConss(scip) + ccall((:SCIPgetOrigConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNCheckConss(scip) + ccall((:SCIPgetNCheckConss, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPaddConflict(scip, node, cons, validnode, conftype::SCIP_CONFTYPE, iscutoffinvolved::UInt32) + ccall((:SCIPaddConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}, SCIP_CONFTYPE, UInt32), scip, node, cons, validnode, conftype, iscutoffinvolved) +end + +function SCIPclearConflictStore(scip, event) + ccall((:SCIPclearConflictStore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENT}), scip, event) +end + +function SCIPaddConsNode(scip, node, cons, validnode) + ccall((:SCIPaddConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, node, cons, validnode) +end + +function SCIPaddConsLocal(scip, cons, validnode) + ccall((:SCIPaddConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, cons, validnode) +end + +function SCIPdelConsNode(scip, node, cons) + ccall((:SCIPdelConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}), scip, node, cons) +end + +function SCIPdelConsLocal(scip, cons) + ccall((:SCIPdelConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPgetLocalOrigEstimate(scip) + ccall((:SCIPgetLocalOrigEstimate, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLocalTransEstimate(scip) + ccall((:SCIPgetLocalTransEstimate, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLocalDualbound(scip) + ccall((:SCIPgetLocalDualbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLocalLowerbound(scip) + ccall((:SCIPgetLocalLowerbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetNodeDualbound(scip, node) + ccall((:SCIPgetNodeDualbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPgetNodeLowerbound(scip, node) + ccall((:SCIPgetNodeLowerbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPupdateLocalDualbound(scip, newbound::Cdouble) + ccall((:SCIPupdateLocalDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) +end + +function SCIPupdateLocalLowerbound(scip, newbound::Cdouble) + ccall((:SCIPupdateLocalLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) +end + +function SCIPupdateNodeDualbound(scip, node, newbound::Cdouble) + ccall((:SCIPupdateNodeDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) +end + +function SCIPupdateNodeLowerbound(scip, node, newbound::Cdouble) + ccall((:SCIPupdateNodeLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) +end + +function SCIPchgChildPrio(scip, child, priority::Cdouble) + ccall((:SCIPchgChildPrio, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, child, priority) +end diff --git a/src/wrapper/scip_probing.jl b/src/wrapper/scip_probing.jl new file mode 100644 index 00000000..6b7c4647 --- /dev/null +++ b/src/wrapper/scip_probing.jl @@ -0,0 +1,111 @@ +# Julia wrapper for header: /usr/include/scip/scip_probing.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPinProbing(scip) + ccall((:SCIPinProbing, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPstartProbing(scip) + ccall((:SCIPstartProbing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPnewProbingNode(scip) + ccall((:SCIPnewProbingNode, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetProbingDepth(scip) + ccall((:SCIPgetProbingDepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPbacktrackProbing(scip, probingdepth::Cint) + ccall((:SCIPbacktrackProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint), scip, probingdepth) +end + +function SCIPendProbing(scip) + ccall((:SCIPendProbing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPchgVarLbProbing(scip, var, newbound::Cdouble) + ccall((:SCIPchgVarLbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPchgVarUbProbing(scip, var, newbound::Cdouble) + ccall((:SCIPchgVarUbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPgetVarObjProbing(scip, var) + ccall((:SCIPgetVarObjProbing, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPfixVarProbing(scip, var, fixedval::Cdouble) + ccall((:SCIPfixVarProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, fixedval) +end + +function SCIPchgVarObjProbing(scip, var, newobj::Cdouble) + ccall((:SCIPchgVarObjProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) +end + +function SCIPisObjChangedProbing(scip) + ccall((:SCIPisObjChangedProbing, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPpropagateProbing(scip, maxproprounds::Cint, cutoff, ndomredsfound) + ccall((:SCIPpropagateProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{Clonglong}), scip, maxproprounds, cutoff, ndomredsfound) +end + +function SCIPpropagateProbingImplications(scip, cutoff) + ccall((:SCIPpropagateProbingImplications, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) +end + +function SCIPsolveProbingLP(scip, itlim::Cint, lperror, cutoff) + ccall((:SCIPsolveProbingLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, itlim, lperror, cutoff) +end + +function SCIPsolveProbingLPWithPricing(scip, pretendroot::UInt32, displayinfo::UInt32, maxpricerounds::Cint, lperror, cutoff) + ccall((:SCIPsolveProbingLPWithPricing, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) +end + +function SCIPsetProbingLPState(scip, lpistate, lpinorms, primalfeas::UInt32, dualfeas::UInt32) + ccall((:SCIPsetProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LPISTATE}}, Ptr{Ptr{SCIP_LPINORMS}}, UInt32, UInt32), scip, lpistate, lpinorms, primalfeas, dualfeas) +end + +function SCIPaddRowProbing(scip, row) + ccall((:SCIPaddRowProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPapplyCutsProbing(scip, cutoff) + ccall((:SCIPapplyCutsProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) +end + +function SCIPsolveProbingRelax(scip, cutoff) + ccall((:SCIPsolveProbingRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) +end + +function SCIPgetDivesetScore(scip, diveset, divetype::SCIP_DIVETYPE, divecand, divecandsol::Cdouble, divecandfrac::Cdouble, candscore, roundup) + ccall((:SCIPgetDivesetScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, SCIP_DIVETYPE, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{UInt32}), scip, diveset, divetype, divecand, divecandsol, divecandfrac, candscore, roundup) +end + +function SCIPupdateDivesetLPStats(scip, diveset, niterstoadd::Clonglong) + ccall((:SCIPupdateDivesetLPStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Clonglong), scip, diveset, niterstoadd) +end + +function SCIPupdateDivesetStats(scip, diveset, nprobingnodes::Cint, nbacktracks::Cint, nsolsfound::Clonglong, nbestsolsfound::Clonglong, nconflictsfound::Clonglong, leavewassol::UInt32) + ccall((:SCIPupdateDivesetStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Cint, Cint, Clonglong, Clonglong, Clonglong, UInt32), scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol) +end + +function SCIPgetDiveBoundChanges(scip, diveset, sol, success, infeasible) + ccall((:SCIPgetDiveBoundChanges, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{UInt32}, Ptr{UInt32}), scip, diveset, sol, success, infeasible) +end + +function SCIPaddDiveBoundChange(scip, var, dir::SCIP_BRANCHDIR, value::Cdouble, preferred::UInt32) + ccall((:SCIPaddDiveBoundChange, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble, UInt32), scip, var, dir, value, preferred) +end + +function SCIPgetDiveBoundChangeData(scip, variables, directions, values, ndivebdchgs, preferred::UInt32) + ccall((:SCIPgetDiveBoundChangeData, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{SCIP_BRANCHDIR}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, UInt32), scip, variables, directions, values, ndivebdchgs, preferred) +end + +function SCIPclearDiveBoundChanges(scip) + ccall((:SCIPclearDiveBoundChanges, libscip), Cvoid, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_prop.jl b/src/wrapper/scip_prop.jl new file mode 100644 index 00000000..ad81f077 --- /dev/null +++ b/src/wrapper/scip_prop.jl @@ -0,0 +1,71 @@ +# Julia wrapper for header: /usr/include/scip/scip_prop.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeProp(scip, name, desc, priority::Cint, freq::Cint, delay::UInt32, timingmask::SCIP_PROPTIMING, presolpriority::Cint, presolmaxrounds::Cint, presoltiming::SCIP_PRESOLTIMING, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) + ccall((:SCIPincludeProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, UInt32, SCIP_PROPTIMING, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, name, desc, priority, freq, delay, timingmask, presolpriority, presolmaxrounds, presoltiming, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) +end + +function SCIPincludePropBasic(scip, propptr, name, desc, priority::Cint, freq::Cint, delay::UInt32, timingmask::SCIP_PROPTIMING, propexec, propdata) + ccall((:SCIPincludePropBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PROP}}, Cstring, Cstring, Cint, Cint, UInt32, SCIP_PROPTIMING, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, propptr, name, desc, priority, freq, delay, timingmask, propexec, propdata) +end + +function SCIPsetPropCopy(scip, prop, propcopy) + ccall((:SCIPsetPropCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propcopy) +end + +function SCIPsetPropFree(scip, prop, propfree) + ccall((:SCIPsetPropFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propfree) +end + +function SCIPsetPropInit(scip, prop, propinit) + ccall((:SCIPsetPropInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinit) +end + +function SCIPsetPropExit(scip, prop, propexit) + ccall((:SCIPsetPropExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexit) +end + +function SCIPsetPropInitsol(scip, prop, propinitsol) + ccall((:SCIPsetPropInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitsol) +end + +function SCIPsetPropExitsol(scip, prop, propexitsol) + ccall((:SCIPsetPropExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitsol) +end + +function SCIPsetPropInitpre(scip, prop, propinitpre) + ccall((:SCIPsetPropInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitpre) +end + +function SCIPsetPropExitpre(scip, prop, propexitpre) + ccall((:SCIPsetPropExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitpre) +end + +function SCIPsetPropPresol(scip, prop, proppresol, presolpriority::Cint, presolmaxrounds::Cint, presoltiming::SCIP_PRESOLTIMING) + ccall((:SCIPsetPropPresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}, Cint, Cint, SCIP_PRESOLTIMING), scip, prop, proppresol, presolpriority, presolmaxrounds, presoltiming) +end + +function SCIPsetPropResprop(scip, prop, propresprop) + ccall((:SCIPsetPropResprop, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propresprop) +end + +function SCIPfindProp(scip, name) + ccall((:SCIPfindProp, libscip), Ptr{SCIP_PROP}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetProps(scip) + ccall((:SCIPgetProps, libscip), Ptr{Ptr{SCIP_PROP}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNProps(scip) + ccall((:SCIPgetNProps, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetPropPriority(scip, prop, priority::Cint) + ccall((:SCIPsetPropPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, priority) +end + +function SCIPsetPropPresolPriority(scip, prop, presolpriority::Cint) + ccall((:SCIPsetPropPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, presolpriority) +end diff --git a/src/wrapper/scip_randnumgen.jl b/src/wrapper/scip_randnumgen.jl new file mode 100644 index 00000000..feb27293 --- /dev/null +++ b/src/wrapper/scip_randnumgen.jl @@ -0,0 +1,19 @@ +# Julia wrapper for header: /usr/include/scip/scip_randnumgen.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPcreateRandom(scip, randnumgen, initialseed::UInt32, useglobalseed::UInt32) + ccall((:SCIPcreateRandom, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}, UInt32, UInt32), scip, randnumgen, initialseed, useglobalseed) +end + +function SCIPfreeRandom(scip, randnumgen) + ccall((:SCIPfreeRandom, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}), scip, randnumgen) +end + +function SCIPsetRandomSeed(scip, randnumgen, seed::UInt32) + ccall((:SCIPsetRandomSeed, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RANDNUMGEN}, UInt32), scip, randnumgen, seed) +end + +function SCIPinitializeRandomSeed(scip, initialseedvalue::UInt32) + ccall((:SCIPinitializeRandomSeed, libscip), UInt32, (Ptr{SCIP}, UInt32), scip, initialseedvalue) +end diff --git a/src/wrapper/scip_reader.jl b/src/wrapper/scip_reader.jl new file mode 100644 index 00000000..152bff73 --- /dev/null +++ b/src/wrapper/scip_reader.jl @@ -0,0 +1,39 @@ +# Julia wrapper for header: /usr/include/scip/scip_reader.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeReader(scip, name, desc, extension, readercopy, readerfree, readerread, readerwrite, readerdata) + ccall((:SCIPincludeReader, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_READERDATA}), scip, name, desc, extension, readercopy, readerfree, readerread, readerwrite, readerdata) +end + +function SCIPincludeReaderBasic(scip, readerptr, name, desc, extension, readerdata) + ccall((:SCIPincludeReaderBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_READER}}, Cstring, Cstring, Cstring, Ptr{SCIP_READERDATA}), scip, readerptr, name, desc, extension, readerdata) +end + +function SCIPsetReaderCopy(scip, reader, readercopy) + ccall((:SCIPsetReaderCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readercopy) +end + +function SCIPsetReaderFree(scip, reader, readerfree) + ccall((:SCIPsetReaderFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerfree) +end + +function SCIPsetReaderRead(scip, reader, readerread) + ccall((:SCIPsetReaderRead, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerread) +end + +function SCIPsetReaderWrite(scip, reader, readerwrite) + ccall((:SCIPsetReaderWrite, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerwrite) +end + +function SCIPfindReader(scip, name) + ccall((:SCIPfindReader, libscip), Ptr{SCIP_READER}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetReaders(scip) + ccall((:SCIPgetReaders, libscip), Ptr{Ptr{SCIP_READER}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNReaders(scip) + ccall((:SCIPgetNReaders, libscip), Cint, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_relax.jl b/src/wrapper/scip_relax.jl new file mode 100644 index 00000000..3ef1c82f --- /dev/null +++ b/src/wrapper/scip_relax.jl @@ -0,0 +1,51 @@ +# Julia wrapper for header: /usr/include/scip/scip_relax.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeRelax(scip, name, desc, priority::Cint, freq::Cint, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) + ccall((:SCIPincludeRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, name, desc, priority, freq, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) +end + +function SCIPincludeRelaxBasic(scip, relaxptr, name, desc, priority::Cint, freq::Cint, relaxexec, relaxdata) + ccall((:SCIPincludeRelaxBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_RELAX}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, relaxptr, name, desc, priority, freq, relaxexec, relaxdata) +end + +function SCIPsetRelaxCopy(scip, relax, relaxcopy) + ccall((:SCIPsetRelaxCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxcopy) +end + +function SCIPsetRelaxFree(scip, relax, relaxfree) + ccall((:SCIPsetRelaxFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxfree) +end + +function SCIPsetRelaxInit(scip, relax, relaxinit) + ccall((:SCIPsetRelaxInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinit) +end + +function SCIPsetRelaxExit(scip, relax, relaxexit) + ccall((:SCIPsetRelaxExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexit) +end + +function SCIPsetRelaxInitsol(scip, relax, relaxinitsol) + ccall((:SCIPsetRelaxInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinitsol) +end + +function SCIPsetRelaxExitsol(scip, relax, relaxexitsol) + ccall((:SCIPsetRelaxExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexitsol) +end + +function SCIPfindRelax(scip, name) + ccall((:SCIPfindRelax, libscip), Ptr{SCIP_RELAX}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetRelaxs(scip) + ccall((:SCIPgetRelaxs, libscip), Ptr{Ptr{SCIP_RELAX}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNRelaxs(scip) + ccall((:SCIPgetNRelaxs, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetRelaxPriority(scip, relax, priority::Cint) + ccall((:SCIPsetRelaxPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint), scip, relax, priority) +end diff --git a/src/wrapper/scip_reopt.jl b/src/wrapper/scip_reopt.jl new file mode 100644 index 00000000..f26f6665 --- /dev/null +++ b/src/wrapper/scip_reopt.jl @@ -0,0 +1,79 @@ +# Julia wrapper for header: /usr/include/scip/scip_reopt.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPgetReoptChildIDs(scip, node, ids, mem::Cint, nids) + ccall((:SCIPgetReoptChildIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}, Cint, Ptr{Cint}), scip, node, ids, mem, nids) +end + +function SCIPgetReoptLeaveIDs(scip, node, ids, mem::Cint, nids) + ccall((:SCIPgetReoptLeaveIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}, Cint, Ptr{Cint}), scip, node, ids, mem, nids) +end + +function SCIPgetNReoptnodes(scip, node) + ccall((:SCIPgetNReoptnodes, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPgetNReoptLeaves(scip, node) + ccall((:SCIPgetNReoptLeaves, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPgetReoptnode(scip, id::UInt32) + ccall((:SCIPgetReoptnode, libscip), Ptr{SCIP_REOPTNODE}, (Ptr{SCIP}, UInt32), scip, id) +end + +function SCIPaddReoptnodeBndchg(scip, reoptnode, var, bound::Cdouble, boundtype::SCIP_BOUNDTYPE) + ccall((:SCIPaddReoptnodeBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{SCIP_VAR}, Cdouble, SCIP_BOUNDTYPE), scip, reoptnode, var, bound, boundtype) +end + +function SCIPsetReoptCompression(scip, representation, nrepresentatives::Cint, success) + ccall((:SCIPsetReoptCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint, Ptr{UInt32}), scip, representation, nrepresentatives, success) +end + +function SCIPaddReoptnodeCons(scip, reoptnode, vars, vals, boundtypes, lhs::Cdouble, rhs::Cdouble, nvars::Cint, constype::REOPT_CONSTYPE, linear::UInt32) + ccall((:SCIPaddReoptnodeCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cdouble, Cdouble, Cint, REOPT_CONSTYPE, UInt32), scip, reoptnode, vars, vals, boundtypes, lhs, rhs, nvars, constype, linear) +end + +function SCIPgetReoptnodePath(scip, reoptnode, vars, vals, boundtypes, mem::Cint, nvars, nafterdualvars) + ccall((:SCIPgetReoptnodePath, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cint, Ptr{Cint}, Ptr{Cint}), scip, reoptnode, vars, vals, boundtypes, mem, nvars, nafterdualvars) +end + +function SCIPinitRepresentation(scip, representatives, nrepresentatives::Cint) + ccall((:SCIPinitRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) +end + +function SCIPresetRepresentation(scip, representatives, nrepresentatives::Cint) + ccall((:SCIPresetRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) +end + +function SCIPfreeRepresentation(scip, representatives, nrepresentatives::Cint) + ccall((:SCIPfreeRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) +end + +function SCIPapplyReopt(scip, reoptnode, id::UInt32, estimate::Cdouble, childnodes, ncreatedchilds, naddedconss, childnodessize::Cint, success) + ccall((:SCIPapplyReopt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, UInt32, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{UInt32}), scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) +end + +function SCIPresetReoptnodeDualcons(scip, node) + ccall((:SCIPresetReoptnodeDualcons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPsplitReoptRoot(scip, ncreatedchilds, naddedconss) + ccall((:SCIPsplitReoptRoot, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}), scip, ncreatedchilds, naddedconss) +end + +function SCIPreoptimizeNode(scip, node) + ccall((:SCIPreoptimizeNode, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPdeleteReoptnode(scip, reoptnode) + ccall((:SCIPdeleteReoptnode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}), scip, reoptnode) +end + +function SCIPgetReoptSimilarity(scip, run1::Cint, run2::Cint) + ccall((:SCIPgetReoptSimilarity, libscip), Cdouble, (Ptr{SCIP}, Cint, Cint), scip, run1, run2) +end + +function SCIPgetVarCoefChg(scip, varidx::Cint, negated, entering, leaving) + ccall((:SCIPgetVarCoefChg, libscip), Cvoid, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, varidx, negated, entering, leaving) +end diff --git a/src/wrapper/scip_sepa.jl b/src/wrapper/scip_sepa.jl new file mode 100644 index 00000000..cc94cfc1 --- /dev/null +++ b/src/wrapper/scip_sepa.jl @@ -0,0 +1,55 @@ +# Julia wrapper for header: /usr/include/scip/scip_sepa.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeSepa(scip, name, desc, priority::Cint, freq::Cint, maxbounddist::Cdouble, usessubscip::UInt32, delay::UInt32, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) + ccall((:SCIPincludeSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) +end + +function SCIPincludeSepaBasic(scip, sepa, name, desc, priority::Cint, freq::Cint, maxbounddist::Cdouble, usessubscip::UInt32, delay::UInt32, sepaexeclp, sepaexecsol, sepadata) + ccall((:SCIPincludeSepaBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SEPA}}, Cstring, Cstring, Cint, Cint, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, sepa, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepaexeclp, sepaexecsol, sepadata) +end + +function SCIPsetSepaCopy(scip, sepa, sepacopy) + ccall((:SCIPsetSepaCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepacopy) +end + +function SCIPsetSepaFree(scip, sepa, sepafree) + ccall((:SCIPsetSepaFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepafree) +end + +function SCIPsetSepaInit(scip, sepa, sepainit) + ccall((:SCIPsetSepaInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainit) +end + +function SCIPsetSepaExit(scip, sepa, sepaexit) + ccall((:SCIPsetSepaExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexit) +end + +function SCIPsetSepaInitsol(scip, sepa, sepainitsol) + ccall((:SCIPsetSepaInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainitsol) +end + +function SCIPsetSepaExitsol(scip, sepa, sepaexitsol) + ccall((:SCIPsetSepaExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexitsol) +end + +function SCIPfindSepa(scip, name) + ccall((:SCIPfindSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetSepas(scip) + ccall((:SCIPgetSepas, libscip), Ptr{Ptr{SCIP_SEPA}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNSepas(scip) + ccall((:SCIPgetNSepas, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetSepaPriority(scip, sepa, priority::Cint) + ccall((:SCIPsetSepaPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Cint), scip, sepa, priority) +end + +function SCIPgetSepaMinEfficacy(scip) + ccall((:SCIPgetSepaMinEfficacy, libscip), Cdouble, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_sol.jl b/src/wrapper/scip_sol.jl new file mode 100644 index 00000000..8ea6d050 --- /dev/null +++ b/src/wrapper/scip_sol.jl @@ -0,0 +1,291 @@ +# Julia wrapper for header: /usr/include/scip/scip_sol.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPcreateSol(scip, sol, heur) + ccall((:SCIPcreateSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateLPSol(scip, sol, heur) + ccall((:SCIPcreateLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateNLPSol(scip, sol, heur) + ccall((:SCIPcreateNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateRelaxSol(scip, sol, heur) + ccall((:SCIPcreateRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreatePseudoSol(scip, sol, heur) + ccall((:SCIPcreatePseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateCurrentSol(scip, sol, heur) + ccall((:SCIPcreateCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreatePartialSol(scip, sol, heur) + ccall((:SCIPcreatePartialSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateUnknownSol(scip, sol, heur) + ccall((:SCIPcreateUnknownSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateOrigSol(scip, sol, heur) + ccall((:SCIPcreateOrigSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateSolCopy(scip, sol, sourcesol) + ccall((:SCIPcreateSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) +end + +function SCIPcreateSolCopyOrig(scip, sol, sourcesol) + ccall((:SCIPcreateSolCopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) +end + +function SCIPcreateFiniteSolCopy(scip, sol, sourcesol, success) + ccall((:SCIPcreateFiniteSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, sourcesol, success) +end + +function SCIPfreeSol(scip, sol) + ccall((:SCIPfreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}), scip, sol) +end + +function SCIPlinkLPSol(scip, sol) + ccall((:SCIPlinkLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPlinkNLPSol(scip, sol) + ccall((:SCIPlinkNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPlinkRelaxSol(scip, sol) + ccall((:SCIPlinkRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPlinkPseudoSol(scip, sol) + ccall((:SCIPlinkPseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPlinkCurrentSol(scip, sol) + ccall((:SCIPlinkCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPclearSol(scip, sol) + ccall((:SCIPclearSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPunlinkSol(scip, sol) + ccall((:SCIPunlinkSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPsetSolVal(scip, sol, var, val::Cdouble) + ccall((:SCIPsetSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, val) +end + +function SCIPsetSolVals(scip, sol, nvars::Cint, vars, vals) + ccall((:SCIPsetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) +end + +function SCIPincSolVal(scip, sol, var, incval::Cdouble) + ccall((:SCIPincSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, incval) +end + +function SCIPgetSolVal(scip, sol, var) + ccall((:SCIPgetSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}), scip, sol, var) +end + +function SCIPgetSolVals(scip, sol, nvars::Cint, vars, vals) + ccall((:SCIPgetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) +end + +function SCIPgetSolOrigObj(scip, sol) + ccall((:SCIPgetSolOrigObj, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPgetSolTransObj(scip, sol) + ccall((:SCIPgetSolTransObj, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPrecomputeSolObj(scip, sol) + ccall((:SCIPrecomputeSolObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPtransformObj(scip, obj::Cdouble) + ccall((:SCIPtransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) +end + +function SCIPretransformObj(scip, obj::Cdouble) + ccall((:SCIPretransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) +end + +function SCIPgetSolTime(scip, sol) + ccall((:SCIPgetSolTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPgetSolRunnum(scip, sol) + ccall((:SCIPgetSolRunnum, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPgetSolNodenum(scip, sol) + ccall((:SCIPgetSolNodenum, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPgetSolHeur(scip, sol) + ccall((:SCIPgetSolHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPareSolsEqual(scip, sol1, sol2) + ccall((:SCIPareSolsEqual, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_SOL}), scip, sol1, sol2) +end + +function SCIPadjustImplicitSolVals(scip, sol, uselprows::UInt32) + ccall((:SCIPadjustImplicitSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32), scip, sol, uselprows) +end + +function SCIPprintSol(scip, sol, file, printzeros::UInt32) + ccall((:SCIPprintSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) +end + +function SCIPprintTransSol(scip, sol, file, printzeros::UInt32) + ccall((:SCIPprintTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) +end + +function SCIPprintMIPStart(scip, sol, file) + ccall((:SCIPprintMIPStart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}), scip, sol, file) +end + +function SCIPgetDualSolVal(scip, cons, dualsolval, boundconstraint) + ccall((:SCIPgetDualSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{UInt32}), scip, cons, dualsolval, boundconstraint) +end + +function SCIPisDualSolAvailable(scip, printreason::UInt32) + ccall((:SCIPisDualSolAvailable, libscip), UInt32, (Ptr{SCIP}, UInt32), scip, printreason) +end + +function SCIPprintDualSol(scip, file, printzeros::UInt32) + ccall((:SCIPprintDualSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) +end + +function SCIPprintRay(scip, sol, file, printzeros::UInt32) + ccall((:SCIPprintRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) +end + +function SCIPgetNSols(scip) + ccall((:SCIPgetNSols, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetSols(scip) + ccall((:SCIPgetSols, libscip), Ptr{Ptr{SCIP_SOL}}, (Ptr{SCIP},), scip) +end + +function SCIPgetBestSol(scip) + ccall((:SCIPgetBestSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP},), scip) +end + +function SCIPprintBestSol(scip, file, printzeros::UInt32) + ccall((:SCIPprintBestSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) +end + +function SCIPprintBestTransSol(scip, file, printzeros::UInt32) + ccall((:SCIPprintBestTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) +end + +function SCIProundSol(scip, sol, success) + ccall((:SCIProundSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, success) +end + +function SCIPretransformSol(scip, sol) + ccall((:SCIPretransformSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPreadSol(scip, filename) + ccall((:SCIPreadSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) +end + +function SCIPreadSolFile(scip, filename, sol, xml::UInt32, partial, error) + ccall((:SCIPreadSolFile, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{SCIP_SOL}, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, filename, sol, xml, partial, error) +end + +function SCIPaddSol(scip, sol, stored) + ccall((:SCIPaddSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, stored) +end + +function SCIPaddSolFree(scip, sol, stored) + ccall((:SCIPaddSolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{UInt32}), scip, sol, stored) +end + +function SCIPaddCurrentSol(scip, heur, stored) + ccall((:SCIPaddCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{UInt32}), scip, heur, stored) +end + +function SCIPtrySol(scip, sol, printreason::UInt32, completely::UInt32, checkbounds::UInt32, checkintegrality::UInt32, checklprows::UInt32, stored) + ccall((:SCIPtrySol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) +end + +function SCIPtrySolFree(scip, sol, printreason::UInt32, completely::UInt32, checkbounds::UInt32, checkintegrality::UInt32, checklprows::UInt32, stored) + ccall((:SCIPtrySolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) +end + +function SCIPtryCurrentSol(scip, heur, printreason::UInt32, completely::UInt32, checkintegrality::UInt32, checklprows::UInt32, stored) + ccall((:SCIPtryCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, heur, printreason, completely, checkintegrality, checklprows, stored) +end + +function SCIPgetPartialSols(scip) + ccall((:SCIPgetPartialSols, libscip), Ptr{Ptr{SCIP_SOL}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNPartialSols(scip) + ccall((:SCIPgetNPartialSols, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPcheckSol(scip, sol, printreason::UInt32, completely::UInt32, checkbounds::UInt32, checkintegrality::UInt32, checklprows::UInt32, feasible) + ccall((:SCIPcheckSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) +end + +function SCIPcheckSolOrig(scip, sol, feasible, printreason::UInt32, completely::UInt32) + ccall((:SCIPcheckSolOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{UInt32}, UInt32, UInt32), scip, sol, feasible, printreason, completely) +end + +function SCIPupdateSolIntegralityViolation(scip, sol, absviol::Cdouble) + ccall((:SCIPupdateSolIntegralityViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble), scip, sol, absviol) +end + +function SCIPupdateSolBoundViolation(scip, sol, absviol::Cdouble, relviol::Cdouble) + ccall((:SCIPupdateSolBoundViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) +end + +function SCIPupdateSolLPRowViolation(scip, sol, absviol::Cdouble, relviol::Cdouble) + ccall((:SCIPupdateSolLPRowViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) +end + +function SCIPupdateSolConsViolation(scip, sol, absviol::Cdouble, relviol::Cdouble) + ccall((:SCIPupdateSolConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) +end + +function SCIPupdateSolLPConsViolation(scip, sol, absviol::Cdouble, relviol::Cdouble) + ccall((:SCIPupdateSolLPConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) +end + +function SCIPactivateSolViolationUpdates(scip) + ccall((:SCIPactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPdeactivateSolViolationUpdates(scip) + ccall((:SCIPdeactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPhasPrimalRay(scip) + ccall((:SCIPhasPrimalRay, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetPrimalRayVal(scip, var) + ccall((:SCIPgetPrimalRayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPupdatePrimalRay(scip, primalray) + ccall((:SCIPupdatePrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, primalray) +end diff --git a/src/wrapper/scip_solve.jl b/src/wrapper/scip_solve.jl new file mode 100644 index 00000000..5990130c --- /dev/null +++ b/src/wrapper/scip_solve.jl @@ -0,0 +1,79 @@ +# Julia wrapper for header: /usr/include/scip/scip_solve.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPtransformProb(scip) + ccall((:SCIPtransformProb, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPpresolve(scip) + ccall((:SCIPpresolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPsolve(scip) + ccall((:SCIPsolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPsolveParallel(scip) + ccall((:SCIPsolveParallel, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPsolveConcurrent(scip) + ccall((:SCIPsolveConcurrent, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPfreeSolve(scip, restart::UInt32) + ccall((:SCIPfreeSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, restart) +end + +function SCIPfreeReoptSolve(scip) + ccall((:SCIPfreeReoptSolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPfreeTransform(scip) + ccall((:SCIPfreeTransform, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPinterruptSolve(scip) + ccall((:SCIPinterruptSolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPrestartSolve(scip) + ccall((:SCIPrestartSolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPenableReoptimization(scip, enable::UInt32) + ccall((:SCIPenableReoptimization, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, enable) +end + +function SCIPisReoptEnabled(scip) + ccall((:SCIPisReoptEnabled, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetReoptSolsRun(scip, run::Cint, sols, allocmem::Cint, nsols) + ccall((:SCIPgetReoptSolsRun, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_SOL}}, Cint, Ptr{Cint}), scip, run, sols, allocmem, nsols) +end + +function SCIPresetReoptSolMarks(scip) + ccall((:SCIPresetReoptSolMarks, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPcheckReoptRestart(scip, node, restart) + ccall((:SCIPcheckReoptRestart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}), scip, node, restart) +end + +function SCIPaddReoptDualBndchg(scip, node, var, newbound::Cdouble, oldbound::Cdouble) + ccall((:SCIPaddReoptDualBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, node, var, newbound, oldbound) +end + +function SCIPgetReoptLastOptSol(scip) + ccall((:SCIPgetReoptLastOptSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP},), scip) +end + +function SCIPgetReoptOldObjCoef(scip, var, run::Cint, objcoef) + ccall((:SCIPgetReoptOldObjCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, run, objcoef) +end + +function SCIPisInRestart(scip) + ccall((:SCIPisInRestart, libscip), UInt32, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_solvingstats.jl b/src/wrapper/scip_solvingstats.jl new file mode 100644 index 00000000..c1f28c06 --- /dev/null +++ b/src/wrapper/scip_solvingstats.jl @@ -0,0 +1,495 @@ +# Julia wrapper for header: /usr/include/scip/scip_solvingstats.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPgetNRuns(scip) + ccall((:SCIPgetNRuns, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNReoptRuns(scip) + ccall((:SCIPgetNReoptRuns, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPaddNNodes(scip, nnodes::Clonglong) + ccall((:SCIPaddNNodes, libscip), Cvoid, (Ptr{SCIP}, Clonglong), scip, nnodes) +end + +function SCIPgetNNodes(scip) + ccall((:SCIPgetNNodes, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNTotalNodes(scip) + ccall((:SCIPgetNTotalNodes, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNFeasibleLeaves(scip) + ccall((:SCIPgetNFeasibleLeaves, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNInfeasibleLeaves(scip) + ccall((:SCIPgetNInfeasibleLeaves, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNObjlimLeaves(scip) + ccall((:SCIPgetNObjlimLeaves, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNDelayedCutoffs(scip) + ccall((:SCIPgetNDelayedCutoffs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPs(scip) + ccall((:SCIPgetNLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNLPIterations(scip) + ccall((:SCIPgetNLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNNZs(scip) + ccall((:SCIPgetNNZs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNRootLPIterations(scip) + ccall((:SCIPgetNRootLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNRootFirstLPIterations(scip) + ccall((:SCIPgetNRootFirstLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrimalLPs(scip) + ccall((:SCIPgetNPrimalLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrimalLPIterations(scip) + ccall((:SCIPgetNPrimalLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNDualLPs(scip) + ccall((:SCIPgetNDualLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNDualLPIterations(scip) + ccall((:SCIPgetNDualLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNBarrierLPs(scip) + ccall((:SCIPgetNBarrierLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNBarrierLPIterations(scip) + ccall((:SCIPgetNBarrierLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNResolveLPs(scip) + ccall((:SCIPgetNResolveLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNResolveLPIterations(scip) + ccall((:SCIPgetNResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrimalResolveLPs(scip) + ccall((:SCIPgetNPrimalResolveLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNPrimalResolveLPIterations(scip) + ccall((:SCIPgetNPrimalResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNDualResolveLPs(scip) + ccall((:SCIPgetNDualResolveLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNDualResolveLPIterations(scip) + ccall((:SCIPgetNDualResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNNodeLPs(scip) + ccall((:SCIPgetNNodeLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNNodeLPIterations(scip) + ccall((:SCIPgetNNodeLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNNodeInitLPs(scip) + ccall((:SCIPgetNNodeInitLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNNodeInitLPIterations(scip) + ccall((:SCIPgetNNodeInitLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNDivingLPs(scip) + ccall((:SCIPgetNDivingLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNDivingLPIterations(scip) + ccall((:SCIPgetNDivingLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNStrongbranchs(scip) + ccall((:SCIPgetNStrongbranchs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNStrongbranchLPIterations(scip) + ccall((:SCIPgetNStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNRootStrongbranchs(scip) + ccall((:SCIPgetNRootStrongbranchs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNRootStrongbranchLPIterations(scip) + ccall((:SCIPgetNRootStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNPriceRounds(scip) + ccall((:SCIPgetNPriceRounds, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPricevars(scip) + ccall((:SCIPgetNPricevars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPricevarsFound(scip) + ccall((:SCIPgetNPricevarsFound, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNPricevarsApplied(scip) + ccall((:SCIPgetNPricevarsApplied, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNSepaRounds(scip) + ccall((:SCIPgetNSepaRounds, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNCutsFound(scip) + ccall((:SCIPgetNCutsFound, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNCutsFoundRound(scip) + ccall((:SCIPgetNCutsFoundRound, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNCutsApplied(scip) + ccall((:SCIPgetNCutsApplied, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNConflictConssFound(scip) + ccall((:SCIPgetNConflictConssFound, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNConflictConssFoundNode(scip) + ccall((:SCIPgetNConflictConssFoundNode, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNConflictConssApplied(scip) + ccall((:SCIPgetNConflictConssApplied, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetMaxDepth(scip) + ccall((:SCIPgetMaxDepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetMaxTotalDepth(scip) + ccall((:SCIPgetMaxTotalDepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNBacktracks(scip) + ccall((:SCIPgetNBacktracks, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNActiveConss(scip) + ccall((:SCIPgetNActiveConss, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNEnabledConss(scip) + ccall((:SCIPgetNEnabledConss, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgDualbound(scip) + ccall((:SCIPgetAvgDualbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgLowerbound(scip) + ccall((:SCIPgetAvgLowerbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetDualbound(scip) + ccall((:SCIPgetDualbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLowerbound(scip) + ccall((:SCIPgetLowerbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetDualboundRoot(scip) + ccall((:SCIPgetDualboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetLowerboundRoot(scip) + ccall((:SCIPgetLowerboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetFirstLPDualboundRoot(scip) + ccall((:SCIPgetFirstLPDualboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetFirstLPLowerboundRoot(scip) + ccall((:SCIPgetFirstLPLowerboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetFirstPrimalBound(scip) + ccall((:SCIPgetFirstPrimalBound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetPrimalbound(scip) + ccall((:SCIPgetPrimalbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetUpperbound(scip) + ccall((:SCIPgetUpperbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetCutoffbound(scip) + ccall((:SCIPgetCutoffbound, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPupdateCutoffbound(scip, cutoffbound::Cdouble) + ccall((:SCIPupdateCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, cutoffbound) +end + +function SCIPisPrimalboundSol(scip) + ccall((:SCIPisPrimalboundSol, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetGap(scip) + ccall((:SCIPgetGap, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetTransGap(scip) + ccall((:SCIPgetTransGap, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetNSolsFound(scip) + ccall((:SCIPgetNSolsFound, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNLimSolsFound(scip) + ccall((:SCIPgetNLimSolsFound, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNBestSolsFound(scip) + ccall((:SCIPgetNBestSolsFound, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgPseudocost(scip, solvaldelta::Cdouble) + ccall((:SCIPgetAvgPseudocost, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) +end + +function SCIPgetAvgPseudocostCurrentRun(scip, solvaldelta::Cdouble) + ccall((:SCIPgetAvgPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) +end + +function SCIPgetAvgPseudocostCount(scip, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetAvgPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) +end + +function SCIPgetAvgPseudocostCountCurrentRun(scip, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetAvgPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) +end + +function SCIPgetPseudocostCount(scip, dir::SCIP_BRANCHDIR, onlycurrentrun::UInt32) + ccall((:SCIPgetPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, UInt32), scip, dir, onlycurrentrun) +end + +function SCIPgetAvgPseudocostScore(scip) + ccall((:SCIPgetAvgPseudocostScore, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetPseudocostVariance(scip, branchdir::SCIP_BRANCHDIR, onlycurrentrun::UInt32) + ccall((:SCIPgetPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, UInt32), scip, branchdir, onlycurrentrun) +end + +function SCIPgetAvgPseudocostScoreCurrentRun(scip) + ccall((:SCIPgetAvgPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgConflictScore(scip) + ccall((:SCIPgetAvgConflictScore, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgConflictScoreCurrentRun(scip) + ccall((:SCIPgetAvgConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgConflictlengthScore(scip) + ccall((:SCIPgetAvgConflictlengthScore, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgConflictlengthScoreCurrentRun(scip) + ccall((:SCIPgetAvgConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgInferences(scip, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetAvgInferences, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) +end + +function SCIPgetAvgInferencesCurrentRun(scip, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) +end + +function SCIPgetAvgInferenceScore(scip) + ccall((:SCIPgetAvgInferenceScore, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgInferenceScoreCurrentRun(scip) + ccall((:SCIPgetAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgCutoffs(scip, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) +end + +function SCIPgetAvgCutoffsCurrentRun(scip, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) +end + +function SCIPgetAvgCutoffScore(scip) + ccall((:SCIPgetAvgCutoffScore, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetAvgCutoffScoreCurrentRun(scip) + ccall((:SCIPgetAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetDeterministicTime(scip) + ccall((:SCIPgetDeterministicTime, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPprintOrigProblem(scip, file, extension, genericnames::UInt32) + ccall((:SCIPprintOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Cstring, UInt32), scip, file, extension, genericnames) +end + +function SCIPprintTransProblem(scip, file, extension, genericnames::UInt32) + ccall((:SCIPprintTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Cstring, UInt32), scip, file, extension, genericnames) +end + +function SCIPprintStatusStatistics(scip, file) + ccall((:SCIPprintStatusStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintTimingStatistics(scip, file) + ccall((:SCIPprintTimingStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintOrigProblemStatistics(scip, file) + ccall((:SCIPprintOrigProblemStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintTransProblemStatistics(scip, file) + ccall((:SCIPprintTransProblemStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintPresolverStatistics(scip, file) + ccall((:SCIPprintPresolverStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintConstraintStatistics(scip, file) + ccall((:SCIPprintConstraintStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintConstraintTimingStatistics(scip, file) + ccall((:SCIPprintConstraintTimingStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintPropagatorStatistics(scip, file) + ccall((:SCIPprintPropagatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintConflictStatistics(scip, file) + ccall((:SCIPprintConflictStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintSeparatorStatistics(scip, file) + ccall((:SCIPprintSeparatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintPricerStatistics(scip, file) + ccall((:SCIPprintPricerStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintBranchruleStatistics(scip, file) + ccall((:SCIPprintBranchruleStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintHeuristicStatistics(scip, file) + ccall((:SCIPprintHeuristicStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintCompressionStatistics(scip, file) + ccall((:SCIPprintCompressionStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintLPStatistics(scip, file) + ccall((:SCIPprintLPStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintNLPStatistics(scip, file) + ccall((:SCIPprintNLPStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintRelaxatorStatistics(scip, file) + ccall((:SCIPprintRelaxatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintTreeStatistics(scip, file) + ccall((:SCIPprintTreeStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintRootStatistics(scip, file) + ccall((:SCIPprintRootStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintSolutionStatistics(scip, file) + ccall((:SCIPprintSolutionStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintConcsolverStatistics(scip, file) + ccall((:SCIPprintConcsolverStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintBendersStatistics(scip, file) + ccall((:SCIPprintBendersStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintStatistics(scip, file) + ccall((:SCIPprintStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintReoptStatistics(scip, file) + ccall((:SCIPprintReoptStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintBranchingStatistics(scip, file) + ccall((:SCIPprintBranchingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) +end + +function SCIPprintDisplayLine(scip, file, verblevel::SCIP_VERBLEVEL, endline::UInt32) + ccall((:SCIPprintDisplayLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, SCIP_VERBLEVEL, UInt32), scip, file, verblevel, endline) +end + +function SCIPgetNImplications(scip) + ccall((:SCIPgetNImplications, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPwriteImplicationConflictGraph(scip, filename) + ccall((:SCIPwriteImplicationConflictGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) +end + +function SCIPstoreSolutionGap(scip) + ccall((:SCIPstoreSolutionGap, libscip), Cvoid, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_table.jl b/src/wrapper/scip_table.jl new file mode 100644 index 00000000..7b99ab42 --- /dev/null +++ b/src/wrapper/scip_table.jl @@ -0,0 +1,19 @@ +# Julia wrapper for header: /usr/include/scip/scip_table.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPincludeTable(scip, name, desc, active::UInt32, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tabledata, position::Cint, earlieststage::SCIP_STAGE) + ccall((:SCIPincludeTable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_TABLEDATA}, Cint, SCIP_STAGE), scip, name, desc, active, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tabledata, position, earlieststage) +end + +function SCIPfindTable(scip, name) + ccall((:SCIPfindTable, libscip), Ptr{SCIP_TABLE}, (Ptr{SCIP}, Cstring), scip, name) +end + +function SCIPgetTables(scip) + ccall((:SCIPgetTables, libscip), Ptr{Ptr{SCIP_TABLE}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNTables(scip) + ccall((:SCIPgetNTables, libscip), Cint, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_timing.jl b/src/wrapper/scip_timing.jl new file mode 100644 index 00000000..6364e8ec --- /dev/null +++ b/src/wrapper/scip_timing.jl @@ -0,0 +1,75 @@ +# Julia wrapper for header: /usr/include/scip/scip_timing.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPgetTimeOfDay(scip) + ccall((:SCIPgetTimeOfDay, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPcreateClock(scip, clck) + ccall((:SCIPcreateClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) +end + +function SCIPcreateCPUClock(scip, clck) + ccall((:SCIPcreateCPUClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) +end + +function SCIPcreateWallClock(scip, clck) + ccall((:SCIPcreateWallClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) +end + +function SCIPfreeClock(scip, clck) + ccall((:SCIPfreeClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) +end + +function SCIPresetClock(scip, clck) + ccall((:SCIPresetClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) +end + +function SCIPstartClock(scip, clck) + ccall((:SCIPstartClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) +end + +function SCIPstopClock(scip, clck) + ccall((:SCIPstopClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) +end + +function SCIPenableOrDisableStatisticTiming(scip) + ccall((:SCIPenableOrDisableStatisticTiming, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPstartSolvingTime(scip) + ccall((:SCIPstartSolvingTime, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPstopSolvingTime(scip) + ccall((:SCIPstopSolvingTime, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetClockTime(scip, clck) + ccall((:SCIPgetClockTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) +end + +function SCIPsetClockTime(scip, clck, sec::Cdouble) + ccall((:SCIPsetClockTime, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}, Cdouble), scip, clck, sec) +end + +function SCIPgetTotalTime(scip) + ccall((:SCIPgetTotalTime, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetSolvingTime(scip) + ccall((:SCIPgetSolvingTime, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetReadingTime(scip) + ccall((:SCIPgetReadingTime, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetPresolvingTime(scip) + ccall((:SCIPgetPresolvingTime, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPgetFirstLPTime(scip) + ccall((:SCIPgetFirstLPTime, libscip), Cdouble, (Ptr{SCIP},), scip) +end diff --git a/src/wrapper/scip_tree.jl b/src/wrapper/scip_tree.jl new file mode 100644 index 00000000..399b2dea --- /dev/null +++ b/src/wrapper/scip_tree.jl @@ -0,0 +1,119 @@ +# Julia wrapper for header: /usr/include/scip/scip_tree.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPgetFocusNode(scip) + ccall((:SCIPgetFocusNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetCurrentNode(scip) + ccall((:SCIPgetCurrentNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetDepth(scip) + ccall((:SCIPgetDepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetFocusDepth(scip) + ccall((:SCIPgetFocusDepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetPlungeDepth(scip) + ccall((:SCIPgetPlungeDepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetRootNode(scip) + ccall((:SCIPgetRootNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetEffectiveRootDepth(scip) + ccall((:SCIPgetEffectiveRootDepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPinRepropagation(scip) + ccall((:SCIPinRepropagation, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPgetChildren(scip, children, nchildren) + ccall((:SCIPgetChildren, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, children, nchildren) +end + +function SCIPgetNChildren(scip) + ccall((:SCIPgetNChildren, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetSiblings(scip, siblings, nsiblings) + ccall((:SCIPgetSiblings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, siblings, nsiblings) +end + +function SCIPgetNSiblings(scip) + ccall((:SCIPgetNSiblings, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetLeaves(scip, leaves, nleaves) + ccall((:SCIPgetLeaves, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, leaves, nleaves) +end + +function SCIPgetNLeaves(scip) + ccall((:SCIPgetNLeaves, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNNodesLeft(scip) + ccall((:SCIPgetNNodesLeft, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetPrioChild(scip) + ccall((:SCIPgetPrioChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetPrioSibling(scip) + ccall((:SCIPgetPrioSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetBestChild(scip) + ccall((:SCIPgetBestChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetBestSibling(scip) + ccall((:SCIPgetBestSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetBestLeaf(scip) + ccall((:SCIPgetBestLeaf, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetBestNode(scip) + ccall((:SCIPgetBestNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetBestboundNode(scip) + ccall((:SCIPgetBestboundNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) +end + +function SCIPgetOpenNodesData(scip, leaves, children, siblings, nleaves, nchildren, nsiblings) + ccall((:SCIPgetOpenNodesData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, leaves, children, siblings, nleaves, nchildren, nsiblings) +end + +function SCIPcutoffNode(scip, node) + ccall((:SCIPcutoffNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPrepropagateNode(scip, node) + ccall((:SCIPrepropagateNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPgetCutoffdepth(scip) + ccall((:SCIPgetCutoffdepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetRepropdepth(scip) + ccall((:SCIPgetRepropdepth, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPprintNodeRootPath(scip, node, file) + ccall((:SCIPprintNodeRootPath, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{FILE}), scip, node, file) +end + +function SCIPsetFocusnodeLP(scip, solvelp::UInt32) + ccall((:SCIPsetFocusnodeLP, libscip), Cvoid, (Ptr{SCIP}, UInt32), scip, solvelp) +end diff --git a/src/wrapper/scip_validation.jl b/src/wrapper/scip_validation.jl new file mode 100644 index 00000000..fc191152 --- /dev/null +++ b/src/wrapper/scip_validation.jl @@ -0,0 +1,7 @@ +# Julia wrapper for header: /usr/include/scip/scip_validation.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPvalidateSolve(scip, primalreference::Cdouble, dualreference::Cdouble, reftol::Cdouble, quiet::UInt32, feasible, primalboundcheck, dualboundcheck) + ccall((:SCIPvalidateSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) +end diff --git a/src/wrapper/scip_var.jl b/src/wrapper/scip_var.jl new file mode 100644 index 00000000..87cc6728 --- /dev/null +++ b/src/wrapper/scip_var.jl @@ -0,0 +1,663 @@ +# Julia wrapper for header: /usr/include/scip/scip_var.h +# Automatically generated using Clang.jl wrap_c, version 0.0.0 + + +function SCIPcreateVar(scip, var, name, lb::Cdouble, ub::Cdouble, obj::Cdouble, vartype::SCIP_VARTYPE, initial::UInt32, removable::UInt32, vardelorig, vartrans, vardeltrans, varcopy, vardata) + ccall((:SCIPcreateVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}), scip, var, name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) +end + +function SCIPcreateVarBasic(scip, var, name, lb::Cdouble, ub::Cdouble, obj::Cdouble, vartype::SCIP_VARTYPE) + ccall((:SCIPcreateVarBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE), scip, var, name, lb, ub, obj, vartype) +end + +function SCIPwriteVarName(scip, file, var, _type::UInt32) + ccall((:SCIPwriteVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{SCIP_VAR}, UInt32), scip, file, var, _type) +end + +function SCIPwriteVarsList(scip, file, vars, nvars::Cint, _type::UInt32, delimiter::UInt8) + ccall((:SCIPwriteVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt8), scip, file, vars, nvars, _type, delimiter) +end + +function SCIPwriteVarsLinearsum(scip, file, vars, vals, nvars::Cint, _type::UInt32) + ccall((:SCIPwriteVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), scip, file, vars, vals, nvars, _type) +end + +function SCIPwriteVarsPolynomial(scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials::Cint, _type::UInt32) + ccall((:SCIPwriteVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}, Cint, UInt32), scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, _type) +end + +function SCIPparseVar(scip, var, str, initial::UInt32, removable::UInt32, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) + ccall((:SCIPparseVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}, Ptr{Cstring}, Ptr{UInt32}), scip, var, str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) +end + +function SCIPparseVarName(scip, str, var, endptr) + ccall((:SCIPparseVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cstring}), scip, str, var, endptr) +end + +function SCIPparseVarsList(scip, str, vars, nvars, varssize::Cint, requiredsize, endptr, delimiter::UInt8, success) + ccall((:SCIPparseVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cstring}, UInt8, Ptr{UInt32}), scip, str, vars, nvars, varssize, requiredsize, endptr, delimiter, success) +end + +function SCIPparseVarsLinearsum(scip, str, vars, vals, nvars, varssize::Cint, requiredsize, endptr, success) + ccall((:SCIPparseVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cstring}, Ptr{UInt32}), scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) +end + +function SCIPparseVarsPolynomial(scip, str, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, endptr, success) + ccall((:SCIPparseVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cstring}, Ptr{UInt32}), scip, str, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, endptr, success) +end + +function SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials::Cint) + ccall((:SCIPfreeParseVarsPolynomialData, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Cint), scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials) +end + +function SCIPcaptureVar(scip, var) + ccall((:SCIPcaptureVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPreleaseVar(scip, var) + ccall((:SCIPreleaseVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}), scip, var) +end + +function SCIPchgVarName(scip, var, name) + ccall((:SCIPchgVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cstring), scip, var, name) +end + +function SCIPtransformVar(scip, var, transvar) + ccall((:SCIPtransformVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) +end + +function SCIPtransformVars(scip, nvars::Cint, vars, transvars) + ccall((:SCIPtransformVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) +end + +function SCIPgetTransformedVar(scip, var, transvar) + ccall((:SCIPgetTransformedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) +end + +function SCIPgetTransformedVars(scip, nvars::Cint, vars, transvars) + ccall((:SCIPgetTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) +end + +function SCIPgetNegatedVar(scip, var, negvar) + ccall((:SCIPgetNegatedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, negvar) +end + +function SCIPgetNegatedVars(scip, nvars::Cint, vars, negvars) + ccall((:SCIPgetNegatedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, negvars) +end + +function SCIPgetBinvarRepresentative(scip, var, repvar, negated) + ccall((:SCIPgetBinvarRepresentative, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), scip, var, repvar, negated) +end + +function SCIPgetBinvarRepresentatives(scip, nvars::Cint, vars, repvars, negated) + ccall((:SCIPgetBinvarRepresentatives, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), scip, nvars, vars, repvars, negated) +end + +function SCIPflattenVarAggregationGraph(scip, var) + ccall((:SCIPflattenVarAggregationGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetProbvarLinearSum(scip, vars, scalars, nvars, varssize::Cint, constant, requiredsize, mergemultiples::UInt32) + ccall((:SCIPgetProbvarLinearSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cdouble}, Ptr{Cint}, UInt32), scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) +end + +function SCIPgetProbvarSum(scip, var, scalar, constant) + ccall((:SCIPgetProbvarSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, scalar, constant) +end + +function SCIPgetActiveVars(scip, vars, nvars, varssize::Cint, requiredsize) + ccall((:SCIPgetActiveVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}), scip, vars, nvars, varssize, requiredsize) +end + +function SCIPgetVarRedcost(scip, var) + ccall((:SCIPgetVarRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarImplRedcost(scip, var, varfixing::UInt32) + ccall((:SCIPgetVarImplRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32), scip, var, varfixing) +end + +function SCIPgetVarFarkasCoef(scip, var) + ccall((:SCIPgetVarFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarLbAtIndex(scip, var, bdchgidx, after::UInt32) + ccall((:SCIPgetVarLbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) +end + +function SCIPgetVarUbAtIndex(scip, var, bdchgidx, after::UInt32) + ccall((:SCIPgetVarUbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) +end + +function SCIPgetVarBdAtIndex(scip, var, boundtype::SCIP_BOUNDTYPE, bdchgidx, after::UInt32) + ccall((:SCIPgetVarBdAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, boundtype, bdchgidx, after) +end + +function SCIPgetVarWasFixedAtIndex(scip, var, bdchgidx, after::UInt32) + ccall((:SCIPgetVarWasFixedAtIndex, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) +end + +function SCIPgetVarSol(scip, var) + ccall((:SCIPgetVarSol, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarSols(scip, nvars::Cint, vars, vals) + ccall((:SCIPgetVarSols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nvars, vars, vals) +end + +function SCIPclearRelaxSolVals(scip) + ccall((:SCIPclearRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPsetRelaxSolVal(scip, var, val::Cdouble) + ccall((:SCIPsetRelaxSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, val) +end + +function SCIPsetRelaxSolVals(scip, nvars::Cint, vars, vals, includeslp::UInt32) + ccall((:SCIPsetRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, UInt32), scip, nvars, vars, vals, includeslp) +end + +function SCIPsetRelaxSolValsSol(scip, sol, includeslp::UInt32) + ccall((:SCIPsetRelaxSolValsSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32), scip, sol, includeslp) +end + +function SCIPisRelaxSolValid(scip) + ccall((:SCIPisRelaxSolValid, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPmarkRelaxSolValid(scip, includeslp::UInt32) + ccall((:SCIPmarkRelaxSolValid, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, includeslp) +end + +function SCIPmarkRelaxSolInvalid(scip) + ccall((:SCIPmarkRelaxSolInvalid, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetRelaxSolVal(scip, var) + ccall((:SCIPgetRelaxSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetRelaxSolObj(scip) + ccall((:SCIPgetRelaxSolObj, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPisStrongbranchDownFirst(scip, var) + ccall((:SCIPisStrongbranchDownFirst, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPstartStrongbranch(scip, enablepropagation::UInt32) + ccall((:SCIPstartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, enablepropagation) +end + +function SCIPendStrongbranch(scip) + ccall((:SCIPendStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetVarStrongbranchFrac(scip, var, itlim::Cint, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarStrongbranchFrac, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +end + +function SCIPgetVarStrongbranchWithPropagation(scip, var, solval::Cdouble, lpobjval::Cdouble, itlim::Cint, maxproprounds::Cint, down, up, downvalid, upvalid, ndomredsdown, ndomredsup, downinf, upinf, downconflict, upconflict, lperror, newlbs, newubs) + ccall((:SCIPgetVarStrongbranchWithPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Clonglong}, Ptr{Clonglong}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, solval, lpobjval, itlim, maxproprounds, down, up, downvalid, upvalid, ndomredsdown, ndomredsup, downinf, upinf, downconflict, upconflict, lperror, newlbs, newubs) +end + +function SCIPgetVarStrongbranchInt(scip, var, itlim::Cint, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarStrongbranchInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +end + +function SCIPgetVarsStrongbranchesFrac(scip, vars, nvars::Cint, itlim::Cint, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarsStrongbranchesFrac, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +end + +function SCIPgetVarsStrongbranchesInt(scip, vars, nvars::Cint, itlim::Cint, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarsStrongbranchesInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +end + +function SCIPgetLastStrongbranchLPSolStat(scip, branchdir::SCIP_BRANCHDIR) + ccall((:SCIPgetLastStrongbranchLPSolStat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, branchdir) +end + +function SCIPgetVarStrongbranchLast(scip, var, down, up, downvalid, upvalid, solval, lpobjval) + ccall((:SCIPgetVarStrongbranchLast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, down, up, downvalid, upvalid, solval, lpobjval) +end + +function SCIPsetVarStrongbranchData(scip, var, lpobjval::Cdouble, primsol::Cdouble, down::Cdouble, up::Cdouble, downvalid::UInt32, upvalid::UInt32, iter::Clonglong, itlim::Cint) + ccall((:SCIPsetVarStrongbranchData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, UInt32, Clonglong, Cint), scip, var, lpobjval, primsol, down, up, downvalid, upvalid, iter, itlim) +end + +function SCIPtryStrongbranchLPSol(scip, foundsol, cutoff) + ccall((:SCIPtryStrongbranchLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}, Ptr{UInt32}), scip, foundsol, cutoff) +end + +function SCIPgetVarStrongbranchNode(scip, var) + ccall((:SCIPgetVarStrongbranchNode, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarStrongbranchLPAge(scip, var) + ccall((:SCIPgetVarStrongbranchLPAge, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarNStrongbranchs(scip, var) + ccall((:SCIPgetVarNStrongbranchs, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPaddVarLocksType(scip, var, locktype::SCIP_LOCKTYPE, nlocksdown::Cint, nlocksup::Cint) + ccall((:SCIPaddVarLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_LOCKTYPE, Cint, Cint), scip, var, locktype, nlocksdown, nlocksup) +end + +function SCIPaddVarLocks(scip, var, nlocksdown::Cint, nlocksup::Cint) + ccall((:SCIPaddVarLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cint), scip, var, nlocksdown, nlocksup) +end + +function SCIPlockVarCons(scip, var, cons, lockdown::UInt32, lockup::UInt32) + ccall((:SCIPlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32), scip, var, cons, lockdown, lockup) +end + +function SCIPunlockVarCons(scip, var, cons, lockdown::UInt32, lockup::UInt32) + ccall((:SCIPunlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32), scip, var, cons, lockdown, lockup) +end + +function SCIPchgVarObj(scip, var, newobj::Cdouble) + ccall((:SCIPchgVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) +end + +function SCIPaddVarObj(scip, var, addobj::Cdouble) + ccall((:SCIPaddVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addobj) +end + +function SCIPadjustedVarLb(scip, var, lb::Cdouble) + ccall((:SCIPadjustedVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lb) +end + +function SCIPadjustedVarUb(scip, var, ub::Cdouble) + ccall((:SCIPadjustedVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, ub) +end + +function SCIPchgVarLb(scip, var, newbound::Cdouble) + ccall((:SCIPchgVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPchgVarUb(scip, var, newbound::Cdouble) + ccall((:SCIPchgVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPchgVarLbNode(scip, node, var, newbound::Cdouble) + ccall((:SCIPchgVarLbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) +end + +function SCIPchgVarUbNode(scip, node, var, newbound::Cdouble) + ccall((:SCIPchgVarUbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) +end + +function SCIPchgVarLbGlobal(scip, var, newbound::Cdouble) + ccall((:SCIPchgVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPchgVarUbGlobal(scip, var, newbound::Cdouble) + ccall((:SCIPchgVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPchgVarLbLazy(scip, var, lazylb::Cdouble) + ccall((:SCIPchgVarLbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazylb) +end + +function SCIPchgVarUbLazy(scip, var, lazyub::Cdouble) + ccall((:SCIPchgVarUbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazyub) +end + +function SCIPtightenVarLb(scip, var, newbound::Cdouble, force::UInt32, infeasible, tightened) + ccall((:SCIPtightenVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) +end + +function SCIPtightenVarUb(scip, var, newbound::Cdouble, force::UInt32, infeasible, tightened) + ccall((:SCIPtightenVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) +end + +function SCIPinferVarFixCons(scip, var, fixedval::Cdouble, infercons, inferinfo::Cint, force::UInt32, infeasible, tightened) + ccall((:SCIPinferVarFixCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infercons, inferinfo, force, infeasible, tightened) +end + +function SCIPinferVarLbCons(scip, var, newbound::Cdouble, infercons, inferinfo::Cint, force::UInt32, infeasible, tightened) + ccall((:SCIPinferVarLbCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) +end + +function SCIPinferVarUbCons(scip, var, newbound::Cdouble, infercons, inferinfo::Cint, force::UInt32, infeasible, tightened) + ccall((:SCIPinferVarUbCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) +end + +function SCIPinferBinvarCons(scip, var, fixedval::UInt32, infercons, inferinfo::Cint, infeasible, tightened) + ccall((:SCIPinferBinvarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_CONS}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infercons, inferinfo, infeasible, tightened) +end + +function SCIPinferVarFixProp(scip, var, fixedval::Cdouble, inferprop, inferinfo::Cint, force::UInt32, infeasible, tightened) + ccall((:SCIPinferVarFixProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, inferprop, inferinfo, force, infeasible, tightened) +end + +function SCIPinferVarLbProp(scip, var, newbound::Cdouble, inferprop, inferinfo::Cint, force::UInt32, infeasible, tightened) + ccall((:SCIPinferVarLbProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) +end + +function SCIPinferVarUbProp(scip, var, newbound::Cdouble, inferprop, inferinfo::Cint, force::UInt32, infeasible, tightened) + ccall((:SCIPinferVarUbProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) +end + +function SCIPinferBinvarProp(scip, var, fixedval::UInt32, inferprop, inferinfo::Cint, infeasible, tightened) + ccall((:SCIPinferBinvarProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_PROP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, inferprop, inferinfo, infeasible, tightened) +end + +function SCIPtightenVarLbGlobal(scip, var, newbound::Cdouble, force::UInt32, infeasible, tightened) + ccall((:SCIPtightenVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) +end + +function SCIPtightenVarUbGlobal(scip, var, newbound::Cdouble, force::UInt32, infeasible, tightened) + ccall((:SCIPtightenVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) +end + +function SCIPcomputeVarLbGlobal(scip, var) + ccall((:SCIPcomputeVarLbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPcomputeVarUbGlobal(scip, var) + ccall((:SCIPcomputeVarUbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPcomputeVarLbLocal(scip, var) + ccall((:SCIPcomputeVarLbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPcomputeVarUbLocal(scip, var) + ccall((:SCIPcomputeVarUbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarMultaggrLbGlobal(scip, var) + ccall((:SCIPgetVarMultaggrLbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarMultaggrUbGlobal(scip, var) + ccall((:SCIPgetVarMultaggrUbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarMultaggrLbLocal(scip, var) + ccall((:SCIPgetVarMultaggrLbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarMultaggrUbLocal(scip, var) + ccall((:SCIPgetVarMultaggrUbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarClosestVlb(scip, var, sol, closestvlb, closestvlbidx) + ccall((:SCIPgetVarClosestVlb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvlb, closestvlbidx) +end + +function SCIPgetVarClosestVub(scip, var, sol, closestvub, closestvubidx) + ccall((:SCIPgetVarClosestVub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvub, closestvubidx) +end + +function SCIPaddVarVlb(scip, var, vlbvar, vlbcoef::Cdouble, vlbconstant::Cdouble, infeasible, nbdchgs) + ccall((:SCIPaddVarVlb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, vlbvar, vlbcoef, vlbconstant, infeasible, nbdchgs) +end + +function SCIPaddVarVub(scip, var, vubvar, vubcoef::Cdouble, vubconstant::Cdouble, infeasible, nbdchgs) + ccall((:SCIPaddVarVub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, vubvar, vubcoef, vubconstant, infeasible, nbdchgs) +end + +function SCIPaddVarImplication(scip, var, varfixing::UInt32, implvar, impltype::SCIP_BOUNDTYPE, implbound::Cdouble, infeasible, nbdchgs) + ccall((:SCIPaddVarImplication, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, varfixing, implvar, impltype, implbound, infeasible, nbdchgs) +end + +function SCIPaddClique(scip, vars, values, nvars::Cint, isequation::UInt32, infeasible, nbdchgs) + ccall((:SCIPaddClique, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}, Cint, UInt32, Ptr{UInt32}, Ptr{Cint}), scip, vars, values, nvars, isequation, infeasible, nbdchgs) +end + +function SCIPcalcCliquePartition(scip, vars, nvars::Cint, cliquepartition, ncliques) + ccall((:SCIPcalcCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, cliquepartition, ncliques) +end + +function SCIPcalcNegatedCliquePartition(scip, vars, nvars::Cint, cliquepartition, ncliques) + ccall((:SCIPcalcNegatedCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, cliquepartition, ncliques) +end + +function SCIPcleanupCliques(scip, infeasible) + ccall((:SCIPcleanupCliques, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, infeasible) +end + +function SCIPgetNCliques(scip) + ccall((:SCIPgetNCliques, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNCliquesCreated(scip) + ccall((:SCIPgetNCliquesCreated, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetCliques(scip) + ccall((:SCIPgetCliques, libscip), Ptr{Ptr{SCIP_CLIQUE}}, (Ptr{SCIP},), scip) +end + +function SCIPhaveVarsCommonClique(scip, var1, value1::UInt32, var2, value2::UInt32, regardimplics::UInt32) + ccall((:SCIPhaveVarsCommonClique, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, UInt32, UInt32), scip, var1, value1, var2, value2, regardimplics) +end + +function SCIPwriteCliqueGraph(scip, fname, writenodeweights::UInt32) + ccall((:SCIPwriteCliqueGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32), scip, fname, writenodeweights) +end + +function SCIPremoveVarFromGlobalStructures(scip, var) + ccall((:SCIPremoveVarFromGlobalStructures, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPchgVarBranchFactor(scip, var, branchfactor::Cdouble) + ccall((:SCIPchgVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, branchfactor) +end + +function SCIPscaleVarBranchFactor(scip, var, scale::Cdouble) + ccall((:SCIPscaleVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, scale) +end + +function SCIPaddVarBranchFactor(scip, var, addfactor::Cdouble) + ccall((:SCIPaddVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addfactor) +end + +function SCIPchgVarBranchPriority(scip, var, branchpriority::Cint) + ccall((:SCIPchgVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) +end + +function SCIPupdateVarBranchPriority(scip, var, branchpriority::Cint) + ccall((:SCIPupdateVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) +end + +function SCIPaddVarBranchPriority(scip, var, addpriority::Cint) + ccall((:SCIPaddVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, addpriority) +end + +function SCIPchgVarBranchDirection(scip, var, branchdirection::SCIP_BRANCHDIR) + ccall((:SCIPchgVarBranchDirection, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, branchdirection) +end + +function SCIPchgVarType(scip, var, vartype::SCIP_VARTYPE, infeasible) + ccall((:SCIPchgVarType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_VARTYPE, Ptr{UInt32}), scip, var, vartype, infeasible) +end + +function SCIPfixVar(scip, var, fixedval::Cdouble, infeasible, fixed) + ccall((:SCIPfixVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infeasible, fixed) +end + +function SCIPaggregateVars(scip, varx, vary, scalarx::Cdouble, scalary::Cdouble, rhs::Cdouble, infeasible, redundant, aggregated) + ccall((:SCIPaggregateVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) +end + +function SCIPmultiaggregateVar(scip, var, naggvars::Cint, aggvars, scalars, constant::Cdouble, infeasible, aggregated) + ccall((:SCIPmultiaggregateVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Ptr{UInt32}, Ptr{UInt32}), scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) +end + +function SCIPdoNotAggr(scip) + ccall((:SCIPdoNotAggr, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPdoNotMultaggr(scip) + ccall((:SCIPdoNotMultaggr, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPdoNotMultaggrVar(scip, var) + ccall((:SCIPdoNotMultaggrVar, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPallowDualReds(scip) + ccall((:SCIPallowDualReds, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPallowObjProp(scip) + ccall((:SCIPallowObjProp, libscip), UInt32, (Ptr{SCIP},), scip) +end + +function SCIPmarkDoNotMultaggrVar(scip, var) + ccall((:SCIPmarkDoNotMultaggrVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPenableVarHistory(scip) + ccall((:SCIPenableVarHistory, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPdisableVarHistory(scip) + ccall((:SCIPdisableVarHistory, libscip), Cvoid, (Ptr{SCIP},), scip) +end + +function SCIPupdateVarPseudocost(scip, var, solvaldelta::Cdouble, objdelta::Cdouble, weight::Cdouble) + ccall((:SCIPupdateVarPseudocost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, var, solvaldelta, objdelta, weight) +end + +function SCIPgetVarPseudocostVal(scip, var, solvaldelta::Cdouble) + ccall((:SCIPgetVarPseudocostVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) +end + +function SCIPgetVarPseudocostValCurrentRun(scip, var, solvaldelta::Cdouble) + ccall((:SCIPgetVarPseudocostValCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) +end + +function SCIPgetVarPseudocost(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarPseudocost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarPseudocostCurrentRun(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarPseudocostCount(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarPseudocostCountCurrentRun(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarPseudocostVariance(scip, var, dir::SCIP_BRANCHDIR, onlycurrentrun::UInt32) + ccall((:SCIPgetVarPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, UInt32), scip, var, dir, onlycurrentrun) +end + +function SCIPcalculatePscostConfidenceBound(scip, var, dir::SCIP_BRANCHDIR, onlycurrentrun::UInt32, clevel::SCIP_CONFIDENCELEVEL) + ccall((:SCIPcalculatePscostConfidenceBound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, UInt32, SCIP_CONFIDENCELEVEL), scip, var, dir, onlycurrentrun, clevel) +end + +function SCIPsignificantVarPscostDifference(scip, varx, fracx::Cdouble, vary, fracy::Cdouble, dir::SCIP_BRANCHDIR, clevel::SCIP_CONFIDENCELEVEL, onesided::UInt32) + ccall((:SCIPsignificantVarPscostDifference, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_VAR}, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL, UInt32), scip, varx, fracx, vary, fracy, dir, clevel, onesided) +end + +function SCIPpscostThresholdProbabilityTest(scip, var, frac::Cdouble, threshold::Cdouble, dir::SCIP_BRANCHDIR, clevel::SCIP_CONFIDENCELEVEL) + ccall((:SCIPpscostThresholdProbabilityTest, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL), scip, var, frac, threshold, dir, clevel) +end + +function SCIPisVarPscostRelerrorReliable(scip, var, threshold::Cdouble, clevel::SCIP_CONFIDENCELEVEL) + ccall((:SCIPisVarPscostRelerrorReliable, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, SCIP_CONFIDENCELEVEL), scip, var, threshold, clevel) +end + +function SCIPgetVarPseudocostScore(scip, var, solval::Cdouble) + ccall((:SCIPgetVarPseudocostScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) +end + +function SCIPgetVarPseudocostScoreCurrentRun(scip, var, solval::Cdouble) + ccall((:SCIPgetVarPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) +end + +function SCIPgetVarVSIDS(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarVSIDS, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarVSIDSCurrentRun(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarVSIDSCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarConflictScore(scip, var) + ccall((:SCIPgetVarConflictScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarConflictScoreCurrentRun(scip, var) + ccall((:SCIPgetVarConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarConflictlengthScore(scip, var) + ccall((:SCIPgetVarConflictlengthScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarConflictlengthScoreCurrentRun(scip, var) + ccall((:SCIPgetVarConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarAvgConflictlength(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarAvgConflictlength, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarAvgConflictlengthCurrentRun(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarAvgConflictlengthCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarAvgInferences(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarAvgInferences, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarAvgInferencesCurrentRun(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarAvgInferenceScore(scip, var) + ccall((:SCIPgetVarAvgInferenceScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarAvgInferenceScoreCurrentRun(scip, var) + ccall((:SCIPgetVarAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPinitVarBranchStats(scip, var, downpscost::Cdouble, uppscost::Cdouble, downvsids::Cdouble, upvsids::Cdouble, downconflen::Cdouble, upconflen::Cdouble, downinfer::Cdouble, upinfer::Cdouble, downcutoff::Cdouble, upcutoff::Cdouble) + ccall((:SCIPinitVarBranchStats, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, var, downpscost, uppscost, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) +end + +function SCIPinitVarValueBranchStats(scip, var, value::Cdouble, downvsids::Cdouble, upvsids::Cdouble, downconflen::Cdouble, upconflen::Cdouble, downinfer::Cdouble, upinfer::Cdouble, downcutoff::Cdouble, upcutoff::Cdouble) + ccall((:SCIPinitVarValueBranchStats, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, var, value, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) +end + +function SCIPgetVarAvgCutoffs(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarAvgCutoffsCurrentRun(scip, var, dir::SCIP_BRANCHDIR) + ccall((:SCIPgetVarAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarAvgCutoffScore(scip, var) + ccall((:SCIPgetVarAvgCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarAvgCutoffScoreCurrentRun(scip, var) + ccall((:SCIPgetVarAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetVarAvgInferenceCutoffScore(scip, var, cutoffweight::Cdouble) + ccall((:SCIPgetVarAvgInferenceCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) +end + +function SCIPgetVarAvgInferenceCutoffScoreCurrentRun(scip, var, cutoffweight::Cdouble) + ccall((:SCIPgetVarAvgInferenceCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) +end + +function SCIPprintVar(scip, var, file) + ccall((:SCIPprintVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{FILE}), scip, var, file) +end From c4bb9acc2e7bf67fd954fc3963c1d149da627d3b Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 14 Dec 2018 23:41:09 +0100 Subject: [PATCH 04/82] wrap selected type_*.h headers - those that appear in the first block in scip.h - but not type_var.h, which yields an error (undefined `union SCIP_DomChg`) --- gen/generate_wrapper.jl | 21 +- src/wrapper/commons.jl | 772 ++++++++++++++++++++++++++++++++++++ src/wrapper/scip_benders.jl | 8 +- src/wrapper/scip_nlp.jl | 24 +- src/wrapper/scip_var.jl | 16 +- 5 files changed, 815 insertions(+), 26 deletions(-) diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index d6cfa3ae..78113dba 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -3,14 +3,31 @@ using Clang header_path = "/usr/include/scip" all_headers = readdir(header_path) +top_types = [ + "type_retcode.h", + "type_result.h", + "type_clock.h", + "type_misc.h", + "type_timing.h", + "type_paramset.h", + "type_event.h", + "type_lp.h", + "type_nlp.h", + # "type_var.h", # has problem with `union SCIP_DomChg` + "type_prob.h", + "type_tree.h", + "type_scip.h", +] + headers = vcat( + top_types, filter(h -> startswith(h, "scip_"), all_headers), ) clang_includes = [ "/usr/lib/llvm-6.0/lib/clang/6.0.0/include", ] -context = wrap_c.init( +context = Clang.wrap_c.init( # header files we want wrapped headers=[joinpath(header_path, h) for h in headers], common_file="commons.jl", @@ -22,4 +39,4 @@ context = wrap_c.init( header_library=header_name -> "libscip" ) -run(context) +Clang.run(context) diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index 8f8d1a87..c415b038 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -1,6 +1,778 @@ # Automatically generated using Clang.jl wrap_c, version 0.0.0 +# begin enum SCIP_Retcode +const SCIP_Retcode = Cint +const SCIP_OKAY = 1 |> Int32 +const SCIP_ERROR = 0 |> Int32 +const SCIP_NOMEMORY = -1 |> Int32 +const SCIP_READERROR = -2 |> Int32 +const SCIP_WRITEERROR = -3 |> Int32 +const SCIP_NOFILE = -4 |> Int32 +const SCIP_FILECREATEERROR = -5 |> Int32 +const SCIP_LPERROR = -6 |> Int32 +const SCIP_NOPROBLEM = -7 |> Int32 +const SCIP_INVALIDCALL = -8 |> Int32 +const SCIP_INVALIDDATA = -9 |> Int32 +const SCIP_INVALIDRESULT = -10 |> Int32 +const SCIP_PLUGINNOTFOUND = -11 |> Int32 +const SCIP_PARAMETERUNKNOWN = -12 |> Int32 +const SCIP_PARAMETERWRONGTYPE = -13 |> Int32 +const SCIP_PARAMETERWRONGVAL = -14 |> Int32 +const SCIP_KEYALREADYEXISTING = -15 |> Int32 +const SCIP_MAXDEPTHLEVEL = -16 |> Int32 +const SCIP_BRANCHERROR = -17 |> Int32 +# end enum SCIP_Retcode + +const SCIP_RETCODE = SCIP_Retcode + +# begin enum SCIP_Result +const SCIP_Result = UInt32 +const SCIP_DIDNOTRUN = 1 |> UInt32 +const SCIP_DELAYED = 2 |> UInt32 +const SCIP_DIDNOTFIND = 3 |> UInt32 +const SCIP_FEASIBLE = 4 |> UInt32 +const SCIP_INFEASIBLE = 5 |> UInt32 +const SCIP_UNBOUNDED = 6 |> UInt32 +const SCIP_CUTOFF = 7 |> UInt32 +const SCIP_SEPARATED = 8 |> UInt32 +const SCIP_NEWROUND = 9 |> UInt32 +const SCIP_REDUCEDDOM = 10 |> UInt32 +const SCIP_CONSADDED = 11 |> UInt32 +const SCIP_CONSCHANGED = 12 |> UInt32 +const SCIP_BRANCHED = 13 |> UInt32 +const SCIP_SOLVELP = 14 |> UInt32 +const SCIP_FOUNDSOL = 15 |> UInt32 +const SCIP_SUSPENDED = 16 |> UInt32 +const SCIP_SUCCESS = 17 |> UInt32 +const SCIP_DELAYNODE = 18 |> UInt32 +# end enum SCIP_Result + +const SCIP_RESULT = SCIP_Result + +# begin enum SCIP_ClockType +const SCIP_ClockType = UInt32 +const SCIP_CLOCKTYPE_DEFAULT = 0 |> UInt32 +const SCIP_CLOCKTYPE_CPU = 1 |> UInt32 +const SCIP_CLOCKTYPE_WALL = 2 |> UInt32 +# end enum SCIP_ClockType + +const SCIP_CLOCKTYPE = SCIP_ClockType + +struct SCIP_Clock +end + +const SCIP_CLOCK = Cvoid + +struct SCIP_CPUClock +end + +const SCIP_CPUCLOCK = Cvoid + +struct SCIP_WallClock +end + +const SCIP_WALLCLOCK = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_SORTINDCOMP ( x ) int x ( void * dataptr , int ind1 , int ind2 ) /** compares two data element pointers +# * result: +# * < 0: elem1 comes before (is better than) elem2 +# * = 0: both elements have the same value +# * > 0: elem2 comes after (is worse than) elem2 +# */ +# Skipping MacroDefinition: SCIP_DECL_SORTPTRCOMP ( x ) int x ( void * elem1 , void * elem2 ) /** gets the key of the given element */ +# Skipping MacroDefinition: SCIP_DECL_HASHGETKEY ( x ) void * x ( void * userptr , void * elem ) /** returns TRUE iff both keys are equal */ +# Skipping MacroDefinition: SCIP_DECL_HASHKEYEQ ( x ) SCIP_Bool x ( void * userptr , void * key1 , void * key2 ) /** returns the hash value of the key */ +# Skipping MacroDefinition: SCIP_DECL_HASHKEYVAL ( x ) uint64_t x ( void * userptr , void * key ) # + +# begin enum SCIP_Confidencelevel +const SCIP_Confidencelevel = UInt32 +const SCIP_CONFIDENCELEVEL_MIN = 0 |> UInt32 +const SCIP_CONFIDENCELEVEL_LOW = 1 |> UInt32 +const SCIP_CONFIDENCELEVEL_MEDIUM = 2 |> UInt32 +const SCIP_CONFIDENCELEVEL_HIGH = 3 |> UInt32 +const SCIP_CONFIDENCELEVEL_MAX = 4 |> UInt32 +# end enum SCIP_Confidencelevel + +const SCIP_CONFIDENCELEVEL = SCIP_Confidencelevel + +struct SCIP_SparseSol +end + +const SCIP_SPARSESOL = Cvoid + +struct SCIP_Queue +end + +const SCIP_QUEUE = Cvoid + +struct SCIP_PQueue +end + +const SCIP_PQUEUE = Cvoid + +struct SCIP_HashTable +end + +const SCIP_HASHTABLE = Cvoid + +struct SCIP_MultiHash +end + +const SCIP_MULTIHASH = Cvoid + +struct SCIP_MultiHashList +end + +const SCIP_MULTIHASHLIST = Cvoid + +struct SCIP_HashMapEntry +end + +const SCIP_HASHMAPENTRY = Cvoid + +struct SCIP_HashMap +end + +const SCIP_HASHMAP = Cvoid + +struct SCIP_HashSet +end + +const SCIP_HASHSET = Cvoid + +struct SCIP_RealArray +end + +const SCIP_REALARRAY = Cvoid + +struct SCIP_IntArray +end + +const SCIP_INTARRAY = Cvoid + +struct SCIP_BoolArray +end + +const SCIP_BOOLARRAY = Cvoid + +struct SCIP_PtrArray +end + +const SCIP_PTRARRAY = Cvoid + +struct SCIP_RandNumGen +end + +const SCIP_RANDNUMGEN = Cvoid + +struct SCIP_ResourceActivity +end + +const SCIP_RESOURCEACTIVITY = Cvoid + +struct SCIP_Profile +end + +const SCIP_PROFILE = Cvoid + +struct SCIP_Digraph +end + +const SCIP_DIGRAPH = Cvoid + +struct SCIP_Bt +end + +const SCIP_BT = Cvoid + +struct SCIP_BtNode +end + +const SCIP_BTNODE = Cvoid + +struct SCIP_Regression +end + +const SCIP_REGRESSION = Cvoid + +struct SCIP_DisjointSet +end + +const SCIP_DISJOINTSET = Cvoid +const SCIP_PRESOLTIMING_NONE = UInt32(0x0002) +const SCIP_PRESOLTIMING_FAST = UInt32(0x0004) +const SCIP_PRESOLTIMING_MEDIUM = UInt32(0x0008) +const SCIP_PRESOLTIMING_EXHAUSTIVE = UInt32(0x0010) +const SCIP_PRESOLTIMING_FINAL = UInt32(0x0020) + +# Skipping MacroDefinition: SCIP_PRESOLTIMING_ALWAYS ( SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM | SCIP_PRESOLTIMING_EXHAUSTIVE ) # +# Skipping MacroDefinition: SCIP_PRESOLTIMING_MAX ( SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM | SCIP_PRESOLTIMING_EXHAUSTIVE | SCIP_PRESOLTIMING_FINAL ) typedef + +const SCIP_PROPTIMING_BEFORELP = UInt32(0x0001) +const SCIP_PROPTIMING_DURINGLPLOOP = UInt32(0x0002) +const SCIP_PROPTIMING_AFTERLPLOOP = UInt32(0x0004) +const SCIP_PROPTIMING_AFTERLPNODE = UInt32(0x0008) + +# Skipping MacroDefinition: SCIP_PROPTIMING_ALWAYS ( SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP | SCIP_PROPTIMING_AFTERLPLOOP | SCIP_PROPTIMING_AFTERLPNODE ) typedef + +const SCIP_HEURTIMING_BEFORENODE = UInt32(0x0001) +const SCIP_HEURTIMING_DURINGLPLOOP = UInt32(0x0002) +const SCIP_HEURTIMING_AFTERLPLOOP = UInt32(0x0004) +const SCIP_HEURTIMING_AFTERLPNODE = UInt32(0x0008) +const SCIP_HEURTIMING_AFTERPSEUDONODE = UInt32(0x0010) +const SCIP_HEURTIMING_AFTERLPPLUNGE = UInt32(0x0020) +const SCIP_HEURTIMING_AFTERPSEUDOPLUNGE = UInt32(0x0040) +const SCIP_HEURTIMING_DURINGPRICINGLOOP = UInt32(0x0080) +const SCIP_HEURTIMING_BEFOREPRESOL = UInt32(0x0100) +const SCIP_HEURTIMING_DURINGPRESOLLOOP = UInt32(0x0200) +const SCIP_HEURTIMING_AFTERPROPLOOP = UInt32(0x0400) + +# Skipping MacroDefinition: SCIP_HEURTIMING_AFTERNODE ( SCIP_HEURTIMING_AFTERLPNODE | SCIP_HEURTIMING_AFTERPSEUDONODE ) /** call heuristic after the processing of the last node in the current plunge was finished */ +# Skipping MacroDefinition: SCIP_HEURTIMING_AFTERPLUNGE ( SCIP_HEURTIMING_AFTERLPPLUNGE | SCIP_HEURTIMING_AFTERPSEUDOPLUNGE ) typedef + +const SCIP_PRESOLTIMING = UInt32 +const SCIP_PROPTIMING = UInt32 +const SCIP_HEURTIMING = UInt32 + +# Skipping MacroDefinition: SCIP_DECL_PARAMCHGD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PARAM * param ) # + +# begin enum SCIP_ParamType +const SCIP_ParamType = UInt32 +const SCIP_PARAMTYPE_BOOL = 0 |> UInt32 +const SCIP_PARAMTYPE_INT = 1 |> UInt32 +const SCIP_PARAMTYPE_LONGINT = 2 |> UInt32 +const SCIP_PARAMTYPE_REAL = 3 |> UInt32 +const SCIP_PARAMTYPE_CHAR = 4 |> UInt32 +const SCIP_PARAMTYPE_STRING = 5 |> UInt32 +# end enum SCIP_ParamType + +const SCIP_PARAMTYPE = SCIP_ParamType + +# begin enum SCIP_ParamSetting +const SCIP_ParamSetting = UInt32 +const SCIP_PARAMSETTING_DEFAULT = 0 |> UInt32 +const SCIP_PARAMSETTING_AGGRESSIVE = 1 |> UInt32 +const SCIP_PARAMSETTING_FAST = 2 |> UInt32 +const SCIP_PARAMSETTING_OFF = 3 |> UInt32 +# end enum SCIP_ParamSetting + +const SCIP_PARAMSETTING = SCIP_ParamSetting + +# begin enum SCIP_ParamEmphasis +const SCIP_ParamEmphasis = UInt32 +const SCIP_PARAMEMPHASIS_DEFAULT = 0 |> UInt32 +const SCIP_PARAMEMPHASIS_CPSOLVER = 1 |> UInt32 +const SCIP_PARAMEMPHASIS_EASYCIP = 2 |> UInt32 +const SCIP_PARAMEMPHASIS_FEASIBILITY = 3 |> UInt32 +const SCIP_PARAMEMPHASIS_HARDLP = 4 |> UInt32 +const SCIP_PARAMEMPHASIS_OPTIMALITY = 5 |> UInt32 +const SCIP_PARAMEMPHASIS_COUNTER = 6 |> UInt32 +const SCIP_PARAMEMPHASIS_PHASEFEAS = 7 |> UInt32 +const SCIP_PARAMEMPHASIS_PHASEIMPROVE = 8 |> UInt32 +const SCIP_PARAMEMPHASIS_PHASEPROOF = 9 |> UInt32 +# end enum SCIP_ParamEmphasis + +const SCIP_PARAMEMPHASIS = SCIP_ParamEmphasis + +struct SCIP_Param +end + +const SCIP_PARAM = Cvoid + +struct SCIP_ParamData +end + +const SCIP_PARAMDATA = Cvoid + +struct SCIP_ParamSet +end + +const SCIP_PARAMSET = Cvoid + +# Skipping MacroDefinition: SCIP_EVENTTYPE_DISABLED UINT64_C ( 0x00000000 ) /**< the event was disabled and has no effect any longer */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARADDED UINT64_C ( 0x00000001 ) /**< a variable has been added to the transformed problem */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARDELETED UINT64_C ( 0x00000002 ) /**< a variable will be deleted from the transformed problem */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARFIXED UINT64_C ( 0x00000004 ) /**< a variable has been fixed, aggregated, or multi-aggregated */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARUNLOCKED UINT64_C ( 0x00000008 ) /**< the number of rounding locks of a variable was reduced to zero or one */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_OBJCHANGED UINT64_C ( 0x00000010 ) /**< the objective value of a variable has been changed */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_GLBCHANGED UINT64_C ( 0x00000020 ) /**< the global lower bound of a variable has been changed */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_GUBCHANGED UINT64_C ( 0x00000040 ) /**< the global upper bound of a variable has been changed */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_LBTIGHTENED UINT64_C ( 0x00000080 ) /**< the local lower bound of a variable has been increased */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_LBRELAXED UINT64_C ( 0x00000100 ) /**< the local lower bound of a variable has been decreased */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_UBTIGHTENED UINT64_C ( 0x00000200 ) /**< the local upper bound of a variable has been decreased */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_UBRELAXED UINT64_C ( 0x00000400 ) /**< the local upper bound of a variable has been increased */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_GHOLEADDED UINT64_C ( 0x00000800 ) /**< a global hole has been added to the hole list of a variable's domain */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_GHOLEREMOVED UINT64_C ( 0x00001000 ) /**< a global hole has been removed from the hole list of a variable's domain */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_LHOLEADDED UINT64_C ( 0x00002000 ) /**< a local hole has been added to the hole list of a variable's domain */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_LHOLEREMOVED UINT64_C ( 0x00004000 ) /**< a local hole has been removed from the hole list of a variable's domain */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_IMPLADDED UINT64_C ( 0x00008000 ) /**< the variable's implication list, variable bound or clique information was extended */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_PRESOLVEROUND UINT64_C ( 0x00010000 ) /**< a presolving round has been finished */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEFOCUSED UINT64_C ( 0x00020000 ) /**< a node has been focused and is now the focus node */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEFEASIBLE UINT64_C ( 0x00040000 ) /**< the LP/pseudo solution of the node was feasible */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEINFEASIBLE UINT64_C ( 0x00080000 ) /**< the focus node has been proven to be infeasible or was bounded */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEBRANCHED UINT64_C ( 0x00100000 ) /**< the focus node has been solved by branching */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_FIRSTLPSOLVED UINT64_C ( 0x00200000 ) /**< the node's initial LP was solved */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_LPSOLVED UINT64_C ( 0x00400000 ) /**< the node's LP was completely solved with cut & price */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_POORSOLFOUND UINT64_C ( 0x00800000 ) /**< a good enough primal feasible (but not new best) solution was found */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_BESTSOLFOUND UINT64_C ( 0x01000000 ) /**< a new best primal feasible solution was found */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWADDEDSEPA UINT64_C ( 0x02000000 ) /**< a row has been added to SCIP's separation storage */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWDELETEDSEPA UINT64_C ( 0x04000000 ) /**< a row has been removed from SCIP's separation storage */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWADDEDLP UINT64_C ( 0x08000000 ) /**< a row has been added to the LP */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWDELETEDLP UINT64_C ( 0x10000000 ) /**< a row has been removed from the LP */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWCOEFCHANGED UINT64_C ( 0x20000000 ) /**< a coefficient of a row has been changed (row specific event) */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWCONSTCHANGED UINT64_C ( 0x40000000 ) /**< the constant of a row has been changed (row specific event) */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWSIDECHANGED UINT64_C ( 0x80000000 ) /**< a side of a row has been changed (row specific event) */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_SYNC UINT64_C ( 0x100000000 ) /**< synchronization event */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_GBDCHANGED ( SCIP_EVENTTYPE_GLBCHANGED | SCIP_EVENTTYPE_GUBCHANGED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_LBCHANGED ( SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_UBCHANGED ( SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_UBRELAXED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_BOUNDTIGHTENED ( SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_UBTIGHTENED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_BOUNDRELAXED ( SCIP_EVENTTYPE_LBRELAXED | SCIP_EVENTTYPE_UBRELAXED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_BOUNDCHANGED ( SCIP_EVENTTYPE_LBCHANGED | SCIP_EVENTTYPE_UBCHANGED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_GHOLECHANGED ( SCIP_EVENTTYPE_GHOLEADDED | SCIP_EVENTTYPE_GHOLEREMOVED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_LHOLECHANGED ( SCIP_EVENTTYPE_LHOLEADDED | SCIP_EVENTTYPE_LHOLEREMOVED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_HOLECHANGED ( SCIP_EVENTTYPE_GHOLECHANGED | SCIP_EVENTTYPE_LHOLECHANGED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_DOMCHANGED ( SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_HOLECHANGED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARCHANGED ( SCIP_EVENTTYPE_VARFIXED | SCIP_EVENTTYPE_VARUNLOCKED | SCIP_EVENTTYPE_OBJCHANGED | SCIP_EVENTTYPE_GBDCHANGED | SCIP_EVENTTYPE_DOMCHANGED | SCIP_EVENTTYPE_IMPLADDED | SCIP_EVENTTYPE_VARDELETED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_VAREVENT ( SCIP_EVENTTYPE_VARADDED | SCIP_EVENTTYPE_VARCHANGED ) /* event masks for node events */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODESOLVED ( SCIP_EVENTTYPE_NODEFEASIBLE | SCIP_EVENTTYPE_NODEINFEASIBLE | SCIP_EVENTTYPE_NODEBRANCHED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEEVENT ( SCIP_EVENTTYPE_NODEFOCUSED | SCIP_EVENTTYPE_NODESOLVED ) /* event masks for LP events */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_LPEVENT ( SCIP_EVENTTYPE_FIRSTLPSOLVED | SCIP_EVENTTYPE_LPSOLVED ) /* event masks for primal solution events */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_SOLFOUND ( SCIP_EVENTTYPE_POORSOLFOUND | SCIP_EVENTTYPE_BESTSOLFOUND ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_SOLEVENT ( SCIP_EVENTTYPE_SOLFOUND ) /* event masks for row events */ +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWCHANGED ( SCIP_EVENTTYPE_ROWCOEFCHANGED | SCIP_EVENTTYPE_ROWCONSTCHANGED | SCIP_EVENTTYPE_ROWSIDECHANGED ) # +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWEVENT ( SCIP_EVENTTYPE_ROWADDEDSEPA | SCIP_EVENTTYPE_ROWDELETEDSEPA | SCIP_EVENTTYPE_ROWADDEDLP | SCIP_EVENTTYPE_ROWDELETEDLP | SCIP_EVENTTYPE_ROWCHANGED ) typedef + +const SCIP_EVENTTYPE_FORMAT = PRIx64 + +# Skipping MacroDefinition: SCIP_DECL_EVENTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** destructor of event handler to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - eventhdlr : the event handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_EVENTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** initialization method of event handler (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - eventhdlr : the event handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_EVENTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** deinitialization method of event handler (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - eventhdlr : the event handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_EVENTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** solving process initialization method of event handler (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The event handler may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - eventhdlr : the event handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_EVENTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** solving process deinitialization method of event handler (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The event handler should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - eventhdlr : the event handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_EVENTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** frees specific event data +# * +# * input: +# * - scip : SCIP main data structure +# * - eventhdlr : the event handler itself +# * - eventdata : pointer to the event data to free +# */ +# Skipping MacroDefinition: SCIP_DECL_EVENTDELETE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr , SCIP_EVENTDATA * * eventdata ) /** execution method of event handler +# * +# * Processes the event. The method is called every time an event occurs, for which the event handler +# * is responsible. Event handlers may declare themselves responsible for events by calling the +# * corresponding SCIPcatch...() method. This method creates an event filter object to point to the +# * given event handler and event data. +# * +# * input: +# * - scip : SCIP main data structure +# * - eventhdlr : the event handler itself +# * - event : event to process +# * - eventdata : user data for the event +# */ +# Skipping MacroDefinition: SCIP_DECL_EVENTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr , SCIP_EVENT * event , SCIP_EVENTDATA * eventdata ) # + +const SCIP_EVENTTYPE = UInt64 + +struct SCIP_Eventhdlr +end + +const SCIP_EVENTHDLR = Cvoid + +struct SCIP_EventhdlrData +end + +const SCIP_EVENTHDLRDATA = Cvoid + +struct SCIP_Event +end + +const SCIP_EVENT = Cvoid + +struct SCIP_EventVarAdded +end + +const SCIP_EVENTVARADDED = Cvoid + +struct SCIP_EventVarDeleted +end + +const SCIP_EVENTVARDELETED = Cvoid + +struct SCIP_EventVarFixed +end + +const SCIP_EVENTVARFIXED = Cvoid + +struct SCIP_EventVarUnlocked +end + +const SCIP_EVENTVARUNLOCKED = Cvoid + +struct SCIP_EventObjChg +end + +const SCIP_EVENTOBJCHG = Cvoid + +struct SCIP_EventBdChg +end + +const SCIP_EVENTBDCHG = Cvoid + +struct SCIP_EventHole +end + +const SCIP_EVENTHOLE = Cvoid + +struct SCIP_EventImplAdd +end + +const SCIP_EVENTIMPLADD = Cvoid + +struct SCIP_EventRowAddedSepa +end + +const SCIP_EVENTROWADDEDSEPA = Cvoid + +struct SCIP_EventRowDeletedSepa +end + +const SCIP_EVENTROWDELETEDSEPA = Cvoid + +struct SCIP_EventRowAddedLP +end + +const SCIP_EVENTROWADDEDLP = Cvoid + +struct SCIP_EventRowDeletedLP +end + +const SCIP_EVENTROWDELETEDLP = Cvoid + +struct SCIP_EventRowCoefChanged +end + +const SCIP_EVENTROWCOEFCHANGED = Cvoid + +struct SCIP_EventRowConstChanged +end + +const SCIP_EVENTROWCONSTCHANGED = Cvoid + +struct SCIP_EventRowSideChanged +end + +const SCIP_EVENTROWSIDECHANGED = Cvoid + +struct SCIP_EventData +end + +const SCIP_EVENTDATA = Cvoid + +struct SCIP_EventFilter +end + +const SCIP_EVENTFILTER = Cvoid + +struct SCIP_EventQueue +end + +const SCIP_EVENTQUEUE = Cvoid + +# begin enum SCIP_LPSolStat +const SCIP_LPSolStat = UInt32 +const SCIP_LPSOLSTAT_NOTSOLVED = 0 |> UInt32 +const SCIP_LPSOLSTAT_OPTIMAL = 1 |> UInt32 +const SCIP_LPSOLSTAT_INFEASIBLE = 2 |> UInt32 +const SCIP_LPSOLSTAT_UNBOUNDEDRAY = 3 |> UInt32 +const SCIP_LPSOLSTAT_OBJLIMIT = 4 |> UInt32 +const SCIP_LPSOLSTAT_ITERLIMIT = 5 |> UInt32 +const SCIP_LPSOLSTAT_TIMELIMIT = 6 |> UInt32 +const SCIP_LPSOLSTAT_ERROR = 7 |> UInt32 +# end enum SCIP_LPSolStat + +const SCIP_LPSOLSTAT = SCIP_LPSolStat + +# begin enum SCIP_BoundType +const SCIP_BoundType = UInt32 +const SCIP_BOUNDTYPE_LOWER = 0 |> UInt32 +const SCIP_BOUNDTYPE_UPPER = 1 |> UInt32 +# end enum SCIP_BoundType + +const SCIP_BOUNDTYPE = SCIP_BoundType + +# begin enum SCIP_SideType +const SCIP_SideType = UInt32 +const SCIP_SIDETYPE_LEFT = 0 |> UInt32 +const SCIP_SIDETYPE_RIGHT = 1 |> UInt32 +# end enum SCIP_SideType + +const SCIP_SIDETYPE = SCIP_SideType + +# begin enum SCIP_RowOriginType +const SCIP_RowOriginType = UInt32 +const SCIP_ROWORIGINTYPE_UNSPEC = 0 |> UInt32 +const SCIP_ROWORIGINTYPE_CONS = 1 |> UInt32 +const SCIP_ROWORIGINTYPE_SEPA = 2 |> UInt32 +const SCIP_ROWORIGINTYPE_REOPT = 3 |> UInt32 +# end enum SCIP_RowOriginType + +const SCIP_ROWORIGINTYPE = SCIP_RowOriginType + +# begin enum SCIP_LPAlgo +const SCIP_LPAlgo = UInt32 +const SCIP_LPALGO_PRIMALSIMPLEX = 0 |> UInt32 +const SCIP_LPALGO_DUALSIMPLEX = 1 |> UInt32 +const SCIP_LPALGO_BARRIER = 2 |> UInt32 +const SCIP_LPALGO_BARRIERCROSSOVER = 3 |> UInt32 +# end enum SCIP_LPAlgo + +const SCIP_LPALGO = SCIP_LPAlgo + +struct SCIP_ColSolVals +end + +const SCIP_COLSOLVALS = Cvoid + +struct SCIP_RowSolVals +end + +const SCIP_ROWSOLVALS = Cvoid + +struct SCIP_LpSolVals +end + +const SCIP_LPSOLVALS = Cvoid + +struct SCIP_Col +end + +const SCIP_COL = Cvoid + +struct SCIP_Row +end + +const SCIP_ROW = Cvoid + +struct SCIP_Lp +end + +const SCIP_LP = Cvoid + +struct SCIP_NlRow +end + +const SCIP_NLROW = Cvoid + +struct SCIP_Nlp +end + +const SCIP_NLP = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_PROBDELORIG ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * * probdata ) /** creates user data of transformed problem by transforming the original user problem data +# * (called after problem was transformed) +# * +# * Because the original problem and the user data of the original problem should not be +# * modified during the solving process, a transformed problem is created as a copy of +# * the original problem. If the user problem data is never modified during the solving +# * process anyways, it is enough to simple copy the user data's pointer. This is the +# * default implementation, which is used when a NULL is given as PROBTRANS method. +# * If the user data may be modified during the solving process (e.g. during preprocessing), +# * the PROBTRANS method must be given and has to copy the user problem data to a different +# * memory location. +# * +# * input: +# * - scip : SCIP main data structure +# * - sourcedata : source problem data to transform +# * - targetdata : pointer to store created transformed problem data +# */ +# Skipping MacroDefinition: SCIP_DECL_PROBTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * sourcedata , SCIP_PROBDATA * * targetdata ) /** frees user data of transformed problem (called when the transformed problem is freed) +# * +# * This method has to be implemented, if the PROBTRANS method is not a simple pointer +# * copy operation like in the default PROBTRANS implementation. It should free the +# * user data of the transformed problem, that was created in the PROBTRANS method. +# * +# * input: +# * - scip : SCIP main data structure +# * - probdata : pointer to the user problem data to free +# */ +# Skipping MacroDefinition: SCIP_DECL_PROBDELTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * * probdata ) /** solving process initialization method of transformed data (called before the branch and bound process begins) +# * +# * This method is called before the branch and bound process begins and can be used to initialize user problem +# * data that depends for example on the number of active problem variables, because these are now fixed. +# * +# * input: +# * - scip : SCIP main data structure +# * - probdata : user problem data +# */ +# Skipping MacroDefinition: SCIP_DECL_PROBINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * probdata ) /** solving process deinitialization method of transformed data (called before the branch and bound data is freed) +# * +# * This method is called before the branch and bound data is freed and should be used to free all data that +# * was allocated in the solving process initialization method. The user has to make sure, that all LP rows associated +# * to the transformed user problem data are released. +# * +# * input: +# * - scip : SCIP main data structure +# * - probdata : user problem data +# * - restart : was this exit solve call triggered by a restart? +# */ +# Skipping MacroDefinition: SCIP_DECL_PROBEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * probdata , SCIP_Bool restart ) /** copies user data of source SCIP for the target SCIP +# * +# * This method should copy the problem data of the source SCIP and create a target problem data for (target) +# * SCIP. Implementing this callback is optional. If the copying process was successful the target SCIP gets this +# * problem data assigned. In case the result pointer is set to SCIP_DIDNOTRUN the target SCIP will have no problem data +# * at all. +# * +# * The variable map and the constraint map can be used via the function SCIPgetVarCopy() and SCIPgetConsCopy(), +# * respectively, to get for certain variables and constraints of the source SCIP the counter parts in the target +# * SCIP. You should be very carefully in using these two methods since they could lead to an infinite loop due to +# * recursion. +# * +# * input: +# * - scip : target SCIP data structure +# * - sourcescip : source SCIP main data structure +# * - sourcedata : source user problem data +# * - varmap, : a hashmap which stores the mapping of source variables to corresponding target variables +# * - consmap, : a hashmap which stores the mapping of source constraints to corresponding target constraints +# * - targetdata : pointer to the target user problem data to create +# * - global : create a global or a local copy? +# * +# * output: +# * - result : pointer to store the result of the call +# * +# * possible return values for *result: +# * - SCIP_DIDNOTRUN : the copying process was not performed +# * - SCIP_SUCCESS : the copying process was successfully performed +# */ +# Skipping MacroDefinition: SCIP_DECL_PROBCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP * sourcescip , SCIP_PROBDATA * sourcedata , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_PROBDATA * * targetdata , SCIP_Bool global , SCIP_RESULT * result ) # + +# begin enum SCIP_Objsense +const SCIP_Objsense = Cint +const SCIP_OBJSENSE_MAXIMIZE = -1 |> Int32 +const SCIP_OBJSENSE_MINIMIZE = 1 |> Int32 +# end enum SCIP_Objsense + +const SCIP_OBJSENSE = SCIP_Objsense + +struct SCIP_Prob +end + +const SCIP_PROB = Cvoid + +struct SCIP_ProbData +end + +const SCIP_PROBDATA = Cvoid + +# begin enum SCIP_NodeType +const SCIP_NodeType = UInt32 +const SCIP_NODETYPE_FOCUSNODE = 0 |> UInt32 +const SCIP_NODETYPE_PROBINGNODE = 1 |> UInt32 +const SCIP_NODETYPE_SIBLING = 2 |> UInt32 +const SCIP_NODETYPE_CHILD = 3 |> UInt32 +const SCIP_NODETYPE_LEAF = 4 |> UInt32 +const SCIP_NODETYPE_DEADEND = 5 |> UInt32 +const SCIP_NODETYPE_JUNCTION = 6 |> UInt32 +const SCIP_NODETYPE_PSEUDOFORK = 7 |> UInt32 +const SCIP_NODETYPE_FORK = 8 |> UInt32 +const SCIP_NODETYPE_SUBROOT = 9 |> UInt32 +const SCIP_NODETYPE_REFOCUSNODE = 10 |> UInt32 +# end enum SCIP_NodeType + +const SCIP_NODETYPE = SCIP_NodeType + +struct SCIP_Probingnode +end + +const SCIP_PROBINGNODE = Cvoid + +struct SCIP_Sibling +end + +const SCIP_SIBLING = Cvoid + +struct SCIP_Child +end + +const SCIP_CHILD = Cvoid + +struct SCIP_Leaf +end + +const SCIP_LEAF = Cvoid + +struct SCIP_Junction +end + +const SCIP_JUNCTION = Cvoid + +struct SCIP_Pseudofork +end + +const SCIP_PSEUDOFORK = Cvoid + +struct SCIP_Fork +end + +const SCIP_FORK = Cvoid + +struct SCIP_Subroot +end + +const SCIP_SUBROOT = Cvoid + +struct SCIP_Node +end + +const SCIP_NODE = Cvoid + +struct SCIP_PendingBdchg +end + +const SCIP_PENDINGBDCHG = Cvoid + +struct SCIP_Tree +end + +const SCIP_TREE = Cvoid + +struct Scip +end + +const SCIP = Cvoid + # Skipping MacroDefinition: SCIPallocMemory ( scip , ptr ) ( ( BMSallocMemory ( ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # # Skipping MacroDefinition: SCIPallocMemoryArray ( scip , ptr , num ) ( ( BMSallocMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # # Skipping MacroDefinition: SCIPallocClearMemoryArray ( scip , ptr , num ) ( ( BMSallocClearMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # diff --git a/src/wrapper/scip_benders.jl b/src/wrapper/scip_benders.jl index f34f43ed..459481d4 100644 --- a/src/wrapper/scip_benders.jl +++ b/src/wrapper/scip_benders.jl @@ -82,8 +82,8 @@ function SCIPsetBendersPriority(scip, benders, priority::Cint) ccall((:SCIPsetBendersPriority, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, priority) end -function SCIPsolveBendersSubproblems(scip, benders, sol, result, infeasible, auxviol, _type::SCIP_BENDERSENFOTYPE, checkint::UInt32) - ccall((:SCIPsolveBendersSubproblems, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}, Ptr{UInt32}, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32), scip, benders, sol, result, infeasible, auxviol, _type, checkint) +function SCIPsolveBendersSubproblems(scip, benders, sol, result, infeasible, auxviol, type::SCIP_BENDERSENFOTYPE, checkint::UInt32) + ccall((:SCIPsolveBendersSubproblems, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}, Ptr{UInt32}, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32), scip, benders, sol, result, infeasible, auxviol, type, checkint) end function SCIPgetBendersMasterVar(scip, benders, var, mappedvar) @@ -106,8 +106,8 @@ function SCIPsetupBendersSubproblem(scip, benders, sol, probnumber::Cint) ccall((:SCIPsetupBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) end -function SCIPsolveBendersSubproblem(scip, benders, sol, probnumber::Cint, infeasible, _type::SCIP_BENDERSENFOTYPE, solvecip::UInt32, objective) - ccall((:SCIPsolveBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32, Ptr{Cdouble}), scip, benders, sol, probnumber, infeasible, _type, solvecip, objective) +function SCIPsolveBendersSubproblem(scip, benders, sol, probnumber::Cint, infeasible, type::SCIP_BENDERSENFOTYPE, solvecip::UInt32, objective) + ccall((:SCIPsolveBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32, Ptr{Cdouble}), scip, benders, sol, probnumber, infeasible, type, solvecip, objective) end function SCIPfreeBendersSubproblem(scip, benders, probnumber::Cint) diff --git a/src/wrapper/scip_nlp.jl b/src/wrapper/scip_nlp.jl index f079f7c4..07cd6b35 100644 --- a/src/wrapper/scip_nlp.jl +++ b/src/wrapper/scip_nlp.jl @@ -118,28 +118,28 @@ function SCIPgetNLPFracVars(scip, fracvars, fracvarssol, fracvarsfrac, nfracvars ccall((:SCIPgetNLPFracVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}), scip, fracvars, fracvarssol, fracvarsfrac, nfracvars, npriofracvars) end -function SCIPgetNLPIntPar(scip, _type::SCIP_NLPPARAM, ival) - ccall((:SCIPgetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cint}), scip, _type, ival) +function SCIPgetNLPIntPar(scip, type::SCIP_NLPPARAM, ival) + ccall((:SCIPgetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cint}), scip, type, ival) end -function SCIPsetNLPIntPar(scip, _type::SCIP_NLPPARAM, ival::Cint) - ccall((:SCIPsetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cint), scip, _type, ival) +function SCIPsetNLPIntPar(scip, type::SCIP_NLPPARAM, ival::Cint) + ccall((:SCIPsetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cint), scip, type, ival) end -function SCIPgetNLPRealPar(scip, _type::SCIP_NLPPARAM, dval) - ccall((:SCIPgetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cdouble}), scip, _type, dval) +function SCIPgetNLPRealPar(scip, type::SCIP_NLPPARAM, dval) + ccall((:SCIPgetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cdouble}), scip, type, dval) end -function SCIPsetNLPRealPar(scip, _type::SCIP_NLPPARAM, dval::Cdouble) - ccall((:SCIPsetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cdouble), scip, _type, dval) +function SCIPsetNLPRealPar(scip, type::SCIP_NLPPARAM, dval::Cdouble) + ccall((:SCIPsetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cdouble), scip, type, dval) end -function SCIPgetNLPStringPar(scip, _type::SCIP_NLPPARAM, sval) - ccall((:SCIPgetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cstring}), scip, _type, sval) +function SCIPgetNLPStringPar(scip, type::SCIP_NLPPARAM, sval) + ccall((:SCIPgetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cstring}), scip, type, sval) end -function SCIPsetNLPStringPar(scip, _type::SCIP_NLPPARAM, sval) - ccall((:SCIPsetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cstring), scip, _type, sval) +function SCIPsetNLPStringPar(scip, type::SCIP_NLPPARAM, sval) + ccall((:SCIPsetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cstring), scip, type, sval) end function SCIPwriteNLP(scip, filename) diff --git a/src/wrapper/scip_var.jl b/src/wrapper/scip_var.jl index 87cc6728..439a6c6e 100644 --- a/src/wrapper/scip_var.jl +++ b/src/wrapper/scip_var.jl @@ -10,20 +10,20 @@ function SCIPcreateVarBasic(scip, var, name, lb::Cdouble, ub::Cdouble, obj::Cdou ccall((:SCIPcreateVarBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE), scip, var, name, lb, ub, obj, vartype) end -function SCIPwriteVarName(scip, file, var, _type::UInt32) - ccall((:SCIPwriteVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{SCIP_VAR}, UInt32), scip, file, var, _type) +function SCIPwriteVarName(scip, file, var, type::UInt32) + ccall((:SCIPwriteVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{SCIP_VAR}, UInt32), scip, file, var, type) end -function SCIPwriteVarsList(scip, file, vars, nvars::Cint, _type::UInt32, delimiter::UInt8) - ccall((:SCIPwriteVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt8), scip, file, vars, nvars, _type, delimiter) +function SCIPwriteVarsList(scip, file, vars, nvars::Cint, type::UInt32, delimiter::UInt8) + ccall((:SCIPwriteVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt8), scip, file, vars, nvars, type, delimiter) end -function SCIPwriteVarsLinearsum(scip, file, vars, vals, nvars::Cint, _type::UInt32) - ccall((:SCIPwriteVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), scip, file, vars, vals, nvars, _type) +function SCIPwriteVarsLinearsum(scip, file, vars, vals, nvars::Cint, type::UInt32) + ccall((:SCIPwriteVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), scip, file, vars, vals, nvars, type) end -function SCIPwriteVarsPolynomial(scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials::Cint, _type::UInt32) - ccall((:SCIPwriteVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}, Cint, UInt32), scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, _type) +function SCIPwriteVarsPolynomial(scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials::Cint, type::UInt32) + ccall((:SCIPwriteVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}, Cint, UInt32), scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, type) end function SCIPparseVar(scip, var, str, initial::UInt32, removable::UInt32, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) From 4d5ef7420671549668791ba4114427e4084e5e1b Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 14 Dec 2018 23:50:46 +0100 Subject: [PATCH 05/82] wrap almost all type_*.h headers --- gen/generate_wrapper.jl | 5 +- src/wrapper/commons.jl | 2901 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 2904 insertions(+), 2 deletions(-) diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index 78113dba..a535bea9 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -13,14 +13,15 @@ top_types = [ "type_event.h", "type_lp.h", "type_nlp.h", - # "type_var.h", # has problem with `union SCIP_DomChg` + "type_var.h", "type_prob.h", "type_tree.h", "type_scip.h", ] headers = vcat( - top_types, + filter(h -> h != "type_var.h", top_types), # problem: `union SCIP_DomChg` + filter(h -> startswith(h, "type_") && !in(h, top_types), all_headers), filter(h -> startswith(h, "scip_"), all_headers), ) clang_includes = [ diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index c415b038..cb680237 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -773,6 +773,2907 @@ end const SCIP = Cvoid +# Skipping MacroDefinition: SCIP_DECL_BANDITFREE ( x ) SCIP_RETCODE x ( BMS_BLKMEM * blkmem , SCIP_BANDIT * bandit \ +#) /** selection callback for bandit selector */ +# Skipping MacroDefinition: SCIP_DECL_BANDITSELECT ( x ) SCIP_RETCODE x ( SCIP_BANDIT * bandit , int * selection \ +#) /** update callback for bandit algorithms */ +# Skipping MacroDefinition: SCIP_DECL_BANDITUPDATE ( x ) SCIP_RETCODE x ( SCIP_BANDIT * bandit , int selection , SCIP_Real score \ +#) /** reset callback for bandit algorithms */ +# Skipping MacroDefinition: SCIP_DECL_BANDITRESET ( x ) SCIP_RETCODE x ( BMS_BUFMEM * bufmem , SCIP_BANDIT * bandit , SCIP_Real * priorities \ +#) # + +struct SCIP_Bandit +end + +const SCIP_BANDIT = Cvoid + +struct SCIP_BanditVTable +end + +const SCIP_BANDITVTABLE = Cvoid + +struct SCIP_BanditData +end + +const SCIP_BANDITDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_BENDERSCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** destructor of Benders' decomposition to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** initialization method of Benders' decomposition (called after problem was transformed and the Benders' decomposition +# * is active) +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** deinitialization method of Benders' decomposition (called before transformed problem is freed and the Benders' +# * decomposition is active) +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** presolving initialization method of the Benders' decomposition (called when presolving is about to begin) +# * +# * This function is called immediately after the auxiliary variables are created in the master problem. The callback +# * provides the user an opportunity to add variable data to the auxiliary variables. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** presolving deinitialization method of the Benders' decomposition (called after presolving has been finished) +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** solving process initialization method of Benders' decomposition (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The Benders' decomposition may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** solving process deinitialization method of Benders' decomposition (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The Benders' decomposition should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** the method for creating the Benders' decomposition subproblem. This method is called during the initialisation stage +# * (after the master problem was transformed). +# * +# * @note When the create subproblem callback is invoked, the mapping between the master problem and subproblem +# * variables must be available. The create subproblem callback is invoked immediately after BENDERSINIT. So, it is +# * possible to construct the variable mapping within the BENDERSINIT callback. +# * +# * This method must register the SCIP instance for the subproblem with the Benders' decomposition core by calling +# * SCIPaddBendersSubproblem. Typically, the user must create the SCIP instances for the subproblems. These can be +# * created within a reader or probdata and then registered with the Benders' decomposition core during the call of this +# * callback. If there are any settings required for solving the subproblems, then they should be set here. However, +# * some settings will be overridden by the standard solving method included in the Benders' decomposition framework. +# * If a special solving method is desired, the user can implement the bendersSolvesubXyz callback. +# * +# * If the user defines a subproblem solving method, then in BENDERSCREATESUB, the user must specify whether the +# * subproblem is convex. This is necessary because the dual solutions from convex problems can be used to generate cuts. +# * The classical Benders' optimality and feasibility cuts require that the subproblems are convex. If the subproblem is +# * convex, then the user must call SCIPbendersSetSubproblemIsConvex() +# * +# * If the user does NOT implement a subproblem solving method, then the convexity of the problem is determined +# * internally. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition data structure +# * - probnumber : the subproblem problem number +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSCREATESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , int probnumber ) /** called before the subproblem solving loop for Benders' decomposition. The pre subproblem solve function gives the +# * user an oppportunity to perform any global set up for the Benders' decomposition. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition data structure +# * - sol : the solution that will be checked in the subproblem. Can be NULL. +# * - type : the enforcement type that called the Benders' decomposition solve. +# * - checkint : should the integer subproblems be checked. +# * - skipsolve : flag to return whether the current subproblem solving loop should be skipped +# * - result : a result to be returned to the Benders' constraint handler if the solve is skipped. If the +# * solve is not skipped, then the returned result is ignored. +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_DIDNOTRUN : the subproblem was not solved in this iteration. Other decompositions will be checked. +# * - SCIP_CONSADDED : a constraint has been added to the master problem. No other decompositions will be checked. +# * - SCIP_SEPARATED : a cut has been added to the master problem. No other decompositions will be checked. +# * - SCIP_FEASIBLE : feasibility of the solution is reported to SCIP. Other decompositions will be checked. +# * - SCIP_INFEASIBLE : infeasibility of the solution is reported to SCIP. No other decompositions will be checked. +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSPRESUBSOLVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , SCIP_BENDERSENFOTYPE type , SCIP_Bool checkint , SCIP_Bool * skipsolve , SCIP_RESULT * result ) /** the solving method for a convex Benders' decomposition subproblem. This call back is provided to solve problems +# * for which the dual soluitons are used to generate Benders' decomposition cuts. In the classical Benders' +# * decomposition implementation, this would be an LP. However, it can be any convex problem where the dual solutions +# * are given by a single vector of reals. +# * +# * In the Benders' decomposition subproblem solving process, there are two solving loops. The first is where the convex +# * subproblems, and the convex relaxations of subproblems, are solved. If no cuts are generated after this solving +# * loop, then the second loop solves subproblems defined as CIPs. This callback is executed during the FIRST solving +# * loop only. +# * +# * In the classical Benders' decomposition implementation, if the subproblems are all LPs the only the +# * BENDERSSOLVESUBCONVEX need to be implemented. If the subproblems are MIPs, then it is useful to only implement a +# * single SCIP instance for the subproblem and then change the variable types of the appropriate variables to +# * CONTINUOUS for the CONVEX subproblem solve and to INTEGER for the CIP subproblem solve. +# * +# * The solving methods are separated so that they can be called in parallel. +# * +# * NOTE: The solving methods must be thread safe. +# * +# * This method is called from within the execution method. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition data structure +# * - sol : the solution that will be checked in the subproblem. Can be NULL. +# * - probnumber : the subproblem problem number +# * - onlyconvexcheck : flag to indicate that only the convex relaxations will be checked in this solving loop. This is +# * a feature of the Large Neighbourhood Benders' Search +# * - objective : variable to return the objective function value of the subproblem +# * - result : the result from solving the subproblem +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_DIDNOTRUN : the subproblem was not solved in this iteration +# * - SCIP_FEASIBLE : the subproblem is solved and is feasible +# * - SCIP_INFEASIBLE : the subproblem is solved and is infeasible +# * - SCIP_UNBOUNDED : the subproblem is solved and is unbounded +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSSOLVESUBCONVEX ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , int probnumber , SCIP_Bool onlyconvexcheck , SCIP_Real * objective , SCIP_RESULT * result ) /** the solving method for a Benders' decomposition subproblem as a CIP. This call back is provided to solve problems +# * for which the dual solutions are not well defined. In this case, the cuts are typically generated from the primal +# * solution to the CIP. In the classical Benders' decomposition implementation, this would be a MIP. However, it can +# * be any CIP. +# * +# * In the Benders' decomposition subproblem solving process, there are two solving loops. The first is where the convex +# * subproblems, and the convex relaxations of subproblems, are solved. If no cuts are generated after this solving +# * loop, then the second loop solves subproblems defined as CIPs. This callback is executed during the SECOND solving +# * loop only. +# * +# * The solving methods are separated so that they can be called in parallel. +# * +# * NOTE: The solving methods must be thread safe. +# * +# * This method is called from within the execution method. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition data structure +# * - sol : the solution that will be checked in the subproblem. Can be NULL. +# * - probnumber : the subproblem problem number +# * - objective : variable to return the objective function value of the subproblem +# * - result : the result from solving the subproblem +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_DIDNOTRUN : the subproblem was not solved in this iteration +# * - SCIP_FEASIBLE : the subproblem is solved and is feasible +# * - SCIP_INFEASIBLE : the subproblem is solved and is infeasible +# * - SCIP_UNBOUNDED : the subproblem is solved and is unbounded +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSSOLVESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , int probnumber , SCIP_Real * objective , SCIP_RESULT * result ) /** the post-solve method for Benders' decomposition. The post-solve method is called after the subproblems have +# * been solved but before they have been freed. After the solving of the Benders' decomposition subproblems, the +# * subproblem solving data is freed in the SCIP_DECL_BENDERSFREESUB callback. However, it is not necessary to implement +# * SCIP_DECL_BENDERSFREESUB. +# * +# * If SCIP_DECL_BENDERSFREESUB is not implemented, then the Benders' decomposition framework will perform a default +# * freeing of the subproblems. If a subproblem is an LP, then they will be in probing mode for the subproblem +# * solve. So the freeing process involves ending the probing mode. If the subproblem is a MIP, then the subproblem is +# * solved by calling SCIPsolve. As such, the transformed problem must be freed after each subproblem solve. +# * +# * This callback provides the opportunity for the user to clean up any data structures that should not exist beyond the current +# * iteration. +# * The user has full access to the master and subproblems in this callback. So it is possible to construct solution for +# * the master problem in the method. +# * Additionally, if there are any subproblems that are infeasibility and this can not be resolved, then the it is +# * possible to merge these subproblems into the master problem. The subproblem indices are given in the mergecands +# * array. The merging can be perform by a user defined function or by calling SCIPmergeBendersSubproblemIntoMaster. If a +# * subproblem was merged into the master problem, then the merged flag must be set to TRUE. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition data structure +# * - sol : the solution that was checked by solving the subproblems. Can be NULL. +# * - type : the enforcement type that called the Benders' decomposition solve. +# * - mergecands : the subproblems that are candidates for merging into the master problem, the first +# * npriomergecands are the priority candidates (they should be merged). The remaining +# * (nmergecands - npriomergecands) are subproblems that could be merged if desired. +# * - npriomergecands : the number of priority merge candidates. +# * - nmergecands : the total number of subproblems that are candidates for merging into the master problem +# * - checkint : should the integer subproblems be checked. +# * - infeasible : indicates whether at least one subproblem is infeasible +# * - merged : flag to indicate whether a subproblem was merged into the master problem. +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSPOSTSOLVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , SCIP_BENDERSENFOTYPE type , int * mergecands , int npriomergecands , int nmergecands , SCIP_Bool checkint , SCIP_Bool infeasible , SCIP_Bool * merged ) /** frees the subproblem so that it can be resolved in the next iteration. As stated above, it is not necessary to +# * implement this callback. If the callback is implemented, the subproblems should be freed by calling +# * SCIPfreeTransform(). However, if the subproblems are LPs, then it could be more efficient to put the subproblem +# * into probing mode prior to solving and then exiting the probing mode during the callback. To put the subproblem into +# * probing mode, the subproblem must be in SCIP_STAGE_SOLVING. This can be achieved by using eventhandlers. +# * +# * If SCIP_DECL_BENDERSFREESUB is not implemented, then the Benders' decomposition framework will perform a default +# * freeing of the subproblems. If a subproblem is an LP, then they will be in probing mode for the subproblem +# * solve. So the freeing process involves ending the probing mode. If the subproblem is a MIP, then the subproblem is +# * solved by calling SCIPsolve. As such, the transformed problem must be freed after each subproblem solve. +# * +# * NOTE: The freeing methods must be thread safe. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition data structure +# * - probnumber : the subproblem problem number +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSFREESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , int probnumber ) /** the variable mapping from the subproblem to the master problem. It is neccessary to have a mapping between every +# * master problem variable and its counterpart in the subproblem. This mapping must go both ways: from master to sub +# * and sub to master. +# * +# * This method is called when generating the cuts. The cuts are generated by using the solution to the subproblem to +# * eliminate a solution to the master problem. +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition structure +# * - var : the variable for which the corresponding variable in the master or subproblem is required +# * - mappedvar : pointer to store the variable that is mapped to var +# * - probnumber : the number of the subproblem that the desired variable belongs to, -1 for the master problem +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSGETVAR ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_VAR * var , SCIP_VAR * * mappedvar , int probnumber ) # + +# begin enum SCIP_BendersEnfoType +const SCIP_BendersEnfoType = UInt32 +const SCIP_BENDERSENFOTYPE_LP = 1 |> UInt32 +const SCIP_BENDERSENFOTYPE_RELAX = 2 |> UInt32 +const SCIP_BENDERSENFOTYPE_PSEUDO = 3 |> UInt32 +const SCIP_BENDERSENFOTYPE_CHECK = 4 |> UInt32 +# end enum SCIP_BendersEnfoType + +const SCIP_BENDERSENFOTYPE = SCIP_BendersEnfoType + +# begin enum SCIP_BendersSolveLoop +const SCIP_BendersSolveLoop = UInt32 +const SCIP_BENDERSSOLVELOOP_CONVEX = 0 |> UInt32 +const SCIP_BENDERSSOLVELOOP_CIP = 1 |> UInt32 +const SCIP_BENDERSSOLVELOOP_USERCONVEX = 2 |> UInt32 +const SCIP_BENDERSSOLVELOOP_USERCIP = 3 |> UInt32 +# end enum SCIP_BendersSolveLoop + +const SCIP_BENDERSSOLVELOOP = SCIP_BendersSolveLoop + +# begin enum SCIP_BendersSubStatus +const SCIP_BendersSubStatus = UInt32 +const SCIP_BENDERSSUBSTATUS_UNKNOWN = 0 |> UInt32 +const SCIP_BENDERSSUBSTATUS_OPTIMAL = 1 |> UInt32 +const SCIP_BENDERSSUBSTATUS_AUXVIOL = 2 |> UInt32 +const SCIP_BENDERSSUBSTATUS_INFEAS = 3 |> UInt32 +# end enum SCIP_BendersSubStatus + +const SCIP_BENDERSSUBSTATUS = SCIP_BendersSubStatus + +struct SCIP_Benders +end + +const SCIP_BENDERS = Cvoid + +struct SCIP_BendersData +end + +const SCIP_BENDERSDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_BENDERSCUT * benderscut ) /** destructor of the Benders' decomposition cut to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - benderscut : the Benders' decomposition cut structure +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** initialization method of the Benders' decomposition cut (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - benderscut : the Benders' decomposition cut structure +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** deinitialization method of the Benders' decomposition cut (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - benderscut : the Benders' decomposition cut structure +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** solving process initialization method of the Benders' decomposition cut (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * +# * input: +# * - scip : SCIP main data structure +# * - benderscut : the Benders' decomposition cut structure +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** solving process deinitialization method of the Benders' decomposition cut (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The Benders' decomposition cut should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - benderscut : the Benders' decomposition cut structure +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** execution method of the Benders' decomposition cut technique +# * +# * input: +# * - scip : SCIP main data structure +# * - benders : the Benders' decomposition structure +# * - benderscut : the Benders' cut structure +# * - sol : the solution that was used for setting up the subproblems +# * - probnumber : the number of the subproblem from which the cut is generated +# * - type : the enforcement type that called the subproblem solve +# * - result : pointer to store the result of the cut algorithm +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_DIDNOTRUN : if the Benders' cut was not run. +# * - SCIP_DIDNOTFIND : if the Benders' cut was run, but there was an error in generating the cut. +# * - SCIP_FEASIBLE : if the Benders' decomposition cut algorithm has not generated a constraint or cut. +# * - SCIP_CONSADDED : an additional constraint for the Benders' decomposition cut was generated +# * - SCIP_SEPARATED : a cutting plane representing the Benders' decomposition cut was generated +# */ +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_BENDERSCUT * benderscut , SCIP_SOL * sol , int probnumber , SCIP_BENDERSENFOTYPE type , SCIP_RESULT * result ) # + +struct SCIP_Benderscut +end + +const SCIP_BENDERSCUT = Cvoid + +struct SCIP_BenderscutData +end + +const SCIP_BENDERSCUTDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_BRANCHCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** destructor of branching method to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - branchrule : the branching rule itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BRANCHFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** initialization method of branching rule (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - branchrule : the branching rule itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BRANCHINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** deinitialization method of branching rule (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - branchrule : the branching rule itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** solving process initialization method of branching rule (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The branching rule may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - branchrule : the branching rule itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BRANCHINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** solving process deinitialization method of branching rule (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The branching rule should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - branchrule : the branching rule itself +# */ +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** branching execution method for fractional LP solutions +# * +# * input: +# * - scip : SCIP main data structure +# * - branchrule : the branching rule itself +# * - allowaddcons : is the branching rule allowed to add constraints to the current node in order to cut off the +# * current solution instead of creating a branching? +# * - result : pointer to store the result of the branching call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the current node was detected to be infeasible +# * - SCIP_CONSADDED : an additional constraint (e.g. a conflict constraint) was generated; this result code must not be +# * returned, if allowaddcons is FALSE +# * - SCIP_REDUCEDDOM : a domain was reduced that rendered the current LP solution infeasible +# * - SCIP_SEPARATED : a cutting plane was generated +# * - SCIP_BRANCHED : branching was applied +# * - SCIP_DIDNOTFIND : the branching rule searched, but did not find a branching +# * - SCIP_DIDNOTRUN : the branching rule was skipped +# */ +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) /** branching execution method for external candidates +# * +# * input: +# * - scip : SCIP main data structure +# * - branchrule : the branching rule itself +# * - allowaddcons : is the branching rule allowed to add constraints to the current node in order to cut off the +# * current solution instead of creating a branching? +# * - result : pointer to store the result of the branching call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the current node was detected to be infeasible +# * - SCIP_CONSADDED : an additional constraint (e.g. a conflict constraint) was generated; this result code must not be +# * returned, if allowaddcons is FALSE +# * - SCIP_REDUCEDDOM : a domain was reduced that rendered the current pseudo solution infeasible +# * - SCIP_BRANCHED : branching was applied +# * - SCIP_DIDNOTFIND : the branching rule searched, but did not find a branching +# * - SCIP_DIDNOTRUN : the branching rule was skipped +# */ +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECEXT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) /** branching execution method for not completely fixed pseudo solutions +# * +# * input: +# * - scip : SCIP main data structure +# * - branchrule : the branching rule itself +# * - allowaddcons : is the branching rule allowed to add constraints to the current node in order to cut off the +# * current solution instead of creating a branching? +# * - result : pointer to store the result of the branching call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the current node was detected to be infeasible +# * - SCIP_CONSADDED : an additional constraint (e.g. a conflict constraint) was generated; this result code must not be +# * returned, if allowaddcons is FALSE +# * - SCIP_REDUCEDDOM : a domain was reduced that rendered the current pseudo solution infeasible +# * - SCIP_BRANCHED : branching was applied +# * - SCIP_DIDNOTFIND : the branching rule searched, but did not find a branching +# * - SCIP_DIDNOTRUN : the branching rule was skipped +# */ +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECPS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) # + +struct SCIP_BranchCand +end + +const SCIP_BRANCHCAND = Cvoid + +struct SCIP_Branchrule +end + +const SCIP_BRANCHRULE = Cvoid + +struct SCIP_BranchruleData +end + +const SCIP_BRANCHRULEDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_COMPRCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** destructor of tree compression to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - compr : the compression technique itself +# */ +# Skipping MacroDefinition: SCIP_DECL_COMPRFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** initialization method of tree compression (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - compr : the compression technique itself +# */ +# Skipping MacroDefinition: SCIP_DECL_COMPRINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** deinitialization method of tree compression (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - compr : the compression technique itself +# */ +# Skipping MacroDefinition: SCIP_DECL_COMPREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** solving process initialization method of tree compressionc (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The tree compression may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - compr : the compression technique itself +# */ +# Skipping MacroDefinition: SCIP_DECL_COMPRINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** solving process deinitialization method of tree compression (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The tree compression should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - compr : the compression technique itself +# */ +# Skipping MacroDefinition: SCIP_DECL_COMPREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** execution method of tree compression technique +# * +# * Try to compress the current search tree. The method is called in the node processing loop. +# * +# * input: +# * - scip : SCIP main data structure +# * - compr : the compression technique itself +# * - result : pointer to store the result of the heuristic call +# * +# * possible return values for *result: +# * - SCIP_SUCCESS : the tree could be compressed +# * - SCIP_DIDNITFIND : the method could not compress the tree +# * - SCIP_DIDNOTRUN : the compression was skipped +# */ +# Skipping MacroDefinition: SCIP_DECL_COMPREXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr , SCIP_RESULT * result ) # + +struct SCIP_Compr +end + +const SCIP_COMPR = Cvoid + +struct SCIP_ComprData +end + +const SCIP_COMPRDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERCREATEINST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONCSOLVERTYPE * concsolvertype , SCIP_CONCSOLVER * concsolver ) /** destroys a concurrent solver instance +# * +# * input: +# * - scip : SCIP main data structure +# * - concsolverinstance : concurrent solver instance to destroy +# * +# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code +# */ +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERDESTROYINST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONCSOLVER * concsolver ) /** frees data of a concurrent solver type +# * +# * input: +# * - scip : SCIP main data structure +# * - data : concurrent solver type data to free +# * +# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code +# */ +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERTYPEFREEDATA ( x ) void x ( SCIP_CONCSOLVERTYPEDATA * * data ) /** initialize random seeds of a concurrent solver +# * +# * input: +# * - concsolver : concurrent solver data structure +# * - seed : seed for initializing the solver's internal random seeds +# * +# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code +# */ +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERINITSEEDS ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , unsigned int seed ) /** synchronization method of concurrent solver for writing data +# * +# * Syncronizes with other solvers. The concurrent solver should pass new solutions +# * and bounds to the syncstore. For the solutions, no more than maxcandsols of the best solution +# * should be considered for sharing. Additionally a maximum if maxsharedsols should be +# * passed to the syncstore. +# * +# * input: +# * - concsolver : concurrent solver data structure +# * - spi : pointer to the SCIP parallel interface +# * - syncdata : concurrent solver data structure +# * - maxcandsols : how many of the best solutions should be considered for sharing +# * - maxsharedsols : the maximum number of solutions that should be shared +# * +# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code +# */ +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSYNCWRITE ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_SYNCSTORE * syncstore , SCIP_SYNCDATA * syncdata , int maxcandsols , int maxsharedsols , int * nsolsshared ) /** synchronization method of concurrent solver for reading data +# * +# * the concurrent solver should read the solutions and bounds stored in the +# * given synchronization data +# * +# * input: +# * - concsolver : concurrent solver data structure +# * - spi : pointer to the SCIP parallel interface +# * - syncdata : concurrent solver data structure +# * +# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code +# */ +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSYNCREAD ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_SYNCSTORE * syncstore , SCIP_SYNCDATA * syncdata , int * nsolsrecvd , int * ntighterbnds , int * ntighterintbnds ) /** execution method of concurrent solver +# * +# * start solving of the problem given during initialization +# * +# * input: +# * - concsolver : concurrent solver data structure +# * +# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code +# */ +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVEREXEC ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_Real * solvingtime , SCIP_Longint * nlpiterations , SCIP_Longint * nnodes ) /** stop the solving as soon as possible +# * +# * input: +# * - concsolver : concurrent solver data structure +# * +# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code +# */ +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSTOP ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver ) /** extract the solving data from the concurrent solver and store it into the SCIP datastructure, +# * so that this SCIP instance has the optimal solution and reports the correct status and statistics. +# * +# * input: +# * - concsolver : concurrent solver data structure +# * - scip : SCIP datastructure +# * +# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code +# */ +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP * scip ) # + +struct SCIP_ConcSolverType +end + +const SCIP_CONCSOLVERTYPE = Cvoid + +struct SCIP_ConcSolverTypeData +end + +const SCIP_CONCSOLVERTYPEDATA = Cvoid + +struct SCIP_ConcSolver +end + +const SCIP_CONCSOLVER = Cvoid + +struct SCIP_ConcSolverData +end + +const SCIP_CONCSOLVERDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_CONFLICTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** destructor of conflict handler to free conflict handler data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - conflicthdlr : the conflict handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_CONFLICTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** initialization method of conflict handler (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - conflicthdlr : the conflict handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_CONFLICTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** deinitialization method of conflict handler (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - conflicthdlr : the conflict handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** solving process initialization method of conflict handler (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The conflict handler may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - conflicthdlr : the conflict handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_CONFLICTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** solving process deinitialization method of conflict handler (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The conflict handler should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - conflicthdlr : the conflict handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** conflict processing method of conflict handler (called when conflict was found) +# * +# * This method is called, when the conflict analysis found a conflict on variable bounds. +# * The conflict handler may update its data accordingly and create a constraint out of the conflict set. +# * If the parameter "resolved" is set, the conflict handler should not create a constraint, because +# * a different conflict handler with higher priority already created a constraint. +# * The bounds in the conflict set lead to a conflict (i.e. an infeasibility) when all enforced at the same time. +# * Thus, a feasible conflict constraint must demand that at least one of the variables in the conflict +# * set violates its corresponding bound, i.e., fulfills the negation of the bound change in the conflict set. +# * For continuous variables, the negation has to be defined in a relaxed way: if, e.g., the bound in the conflict +# * set is "x <= u", the negation to be used has to be "x >= u", and not "x > u". +# * The given "bdchginfos" array representing the conflict set is only a reference to an internal +# * buffer, that may be modified at any time by SCIP. The user must copy the needed information from the +# * "bdchginfos" array to own data structures, if (s)he wants to use the information later. +# * (S)he should not keep a pointer to the array or pointers to the single bdchginfos in the array, because these +# * may get invalid afterwards. +# * +# * input: +# * - scip : SCIP main data structure +# * - conflicthdlr : the conflict handler itself +# * - node : node to add resulting conflict constraint to (with SCIPaddConsNode()) +# * - validnode : node at which the conflict constraint is valid (should be passed to SCIPaddConsNode()) +# * - bdchginfos : array with bound changes that lead to a conflict +# * - relaxedbds : array with relaxed bounds which are efficient to create a valid conflict +# * - nbdchginfos : number of bound changes in the conflict set +# * -.primalbound : the current primal bound, or -infininity if the conflict arises from an infeasible LP +# * - separate : should the conflict constraint be separated? +# * - local : is the conflict set only valid locally, i.e., should the constraint be created as local constraint? +# * - dynamic : should the conflict constraint be made subject to aging? +# * - removable : should the conflict's relaxation be made subject to LP aging and cleanup? +# * - resolved : is the conflict set already used to create a constraint? +# * - result : pointer to store the result of the conflict processing call +# * +# * possible return values for *result: +# * - SCIP_CONSADDED : the conflict handler created a constraint out of the conflict set +# * - SCIP_DIDNOTFIND : the conflict handler could not create a constraint out of the conflict set +# * - SCIP_DIDNOTRUN : the conflict handler was skipped +# */ +# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr , SCIP_NODE * node , SCIP_NODE * validnode , SCIP_BDCHGINFO * * bdchginfos , SCIP_Real * relaxedbds , int nbdchginfos , SCIP_CONFTYPE conftype , SCIP_Bool cutoffinvolved , SCIP_Bool separate , SCIP_Bool local , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool resolved , SCIP_RESULT * result ) # + +struct SCIP_Conflicthdlr +end + +const SCIP_CONFLICTHDLR = Cvoid + +struct SCIP_ConflicthdlrData +end + +const SCIP_CONFLICTHDLRDATA = Cvoid + +struct SCIP_ConflictSet +end + +const SCIP_CONFLICTSET = Cvoid + +struct SCIP_ProofSet +end + +const SCIP_PROOFSET = Cvoid + +struct SCIP_LPBdChgs +end + +const SCIP_LPBDCHGS = Cvoid + +struct SCIP_Conflict +end + +const SCIP_CONFLICT = Cvoid + +# begin enum SCIP_ConflictType +const SCIP_ConflictType = UInt32 +const SCIP_CONFTYPE_UNKNOWN = 0 |> UInt32 +const SCIP_CONFTYPE_PROPAGATION = 1 |> UInt32 +const SCIP_CONFTYPE_INFEASLP = 2 |> UInt32 +const SCIP_CONFTYPE_BNDEXCEEDING = 3 |> UInt32 +const SCIP_CONFTYPE_ALTINFPROOF = 4 |> UInt32 +const SCIP_CONFTYPE_ALTBNDPROOF = 5 |> UInt32 +# end enum SCIP_ConflictType + +const SCIP_CONFTYPE = SCIP_ConflictType + +# begin enum SCIP_ConflictPresolStrat +const SCIP_ConflictPresolStrat = UInt32 +const SCIP_CONFPRES_DISABLED = 0 |> UInt32 +const SCIP_CONFPRES_ONLYLOCAL = 1 |> UInt32 +const SCIP_CONFPRES_ONLYGLOBAL = 2 |> UInt32 +const SCIP_CONFPRES_BOTH = 3 |> UInt32 +# end enum SCIP_ConflictPresolStrat + +const SCIP_CONFPRES = SCIP_ConflictPresolStrat + +# Skipping MacroDefinition: SCIP_NLINCONSTYPES ( ( int ) SCIP_LINCONSTYPE_GENERAL + 1 ) /** copy method for constraint handler plugins (called when SCIP copies plugins) +# * +# * If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, this pointer has to be set to +# * FALSE. If all problem defining objects (constraint handlers and variable pricers) return valid = TRUE for all +# * their copying calls, SCIP assumes that it is an overall one to one copy of the original instance. In this case any +# * reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is +# * set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - valid : was the copying process valid? +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSHDLRCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_Bool * valid ) /** destructor of constraint handler to free constraint handler data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr ) /** initialization method of constraint handler (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints in transformed problem +# * - nconss : number of constraints in transformed problem +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** deinitialization method of constraint handler (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints in transformed problem +# * - nconss : number of constraints in transformed problem +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** presolving initialization method of constraint handler (called when presolving is about to begin) +# * +# * This method is called when the presolving process is about to begin, even if presolving is turned off. +# * The constraint handler may use this call to initialize its data structures. +# * +# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the +# * presolving deinitialization call (SCIP_DECL_CONSEXITPRE()). +# * +# * @note Note that the constraint array might contain constraints that were created but not added to the problem. +# * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem +# * reductions. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints in transformed problem +# * - nconss : number of constraints in transformed problem +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** presolving deinitialization method of constraint handler (called after presolving has been finished) +# * +# * This method is called after the presolving has been finished, even if presolving is turned off. +# * The constraint handler may use this call e.g. to clean up or modify its data structures. +# * +# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the +# * presolving initialization call (SCIP_DECL_CONSINITPRE()). +# * +# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the +# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, +# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. +# * +# * @note Note that the constraint array might contain constraints that were created but not added to the problem. +# * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem +# * reductions. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : final array of constraints in transformed problem +# * - nconss : final number of constraints in transformed problem +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** solving process initialization method of constraint handler (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The constraint handler may use this call to initialize its branch and bound specific data. +# * +# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the +# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, +# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. +# * +# * @note Note that the constraint array might contain constraints that were created but not added to the problem. +# * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem +# * reductions. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints of the constraint handler +# * - nconss : number of constraints of the constraint handler +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** solving process deinitialization method of constraint handler (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The constraint handler should use this call to clean up its branch and bound data, in particular to release +# * all LP rows that he has created or captured. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints of the constraint handler +# * - nconss : number of constraints of the constraint handler +# * - restart : was this exit solve call triggered by a restart? +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_Bool restart ) /** frees specific constraint data +# * +# * @warning There may exist unprocessed events. For example, a variable's bound may have been already changed, but the +# * corresponding bound change event was not yet processed. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint belonging to the constraint data +# * - consdata : pointer to the constraint data to free +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSDELETE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_CONSDATA * * consdata ) /** transforms constraint data into data belonging to the transformed problem +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - sourcecons : source constraint to transform +# * - targetcons : pointer to store created target constraint +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * sourcecons , SCIP_CONS * * targetcons ) /** LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved) +# * +# * Puts the LP relaxations of all "initial" constraints into the LP. The method should put a canonic LP relaxation +# * of all given constraints to the LP with calls to SCIPaddRow(). +# * +# * @warning It is not guaranteed that the problem is going to be declared infeasible if the infeasible pointer is set +# * to TRUE. Therefore, it is recommended that users do not end this method prematurely when an infeasiblity +# * is detected. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * +# * output: +# * - infeasible : pointer to store whether an infeasibility was detected while building the LP +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSINITLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_Bool * infeasible ) /** separation method of constraint handler for LP solution +# * +# * Separates all constraints of the constraint handler. The method is called in the LP solution loop, +# * which means that a valid LP solution exists. +# * +# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation +# * method should process only the useful constraints in most runs, and only occasionally the remaining +# * nconss - nusefulconss constraints. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * - nusefulconss : number of useful (non-obsolete) constraints to process +# * - result : pointer to store the result of the separation call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_CONSADDED : an additional constraint was generated +# * - SCIP_REDUCEDDOM : a variable's domain was reduced +# * - SCIP_SEPARATED : a cutting plane was generated +# * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start +# * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints +# * - SCIP_DIDNOTRUN : the separator was skipped +# * - SCIP_DELAYED : the separator was skipped, but should be called again +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSSEPALP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_RESULT * result ) /** separation method of constraint handler for arbitrary primal solution +# * +# * Separates all constraints of the constraint handler. The method is called outside the LP solution loop (e.g., by +# * a relaxator or a primal heuristic), which means that there is no valid LP solution. +# * Instead, the method should produce cuts that separate the given solution. +# * +# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation +# * method should process only the useful constraints in most runs, and only occasionally the remaining +# * nconss - nusefulconss constraints. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * - nusefulconss : number of useful (non-obsolete) constraints to process +# * - sol : primal solution that should be separated +# * - result : pointer to store the result of the separation call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_CONSADDED : an additional constraint was generated +# * - SCIP_REDUCEDDOM : a variable's domain was reduced +# * - SCIP_SEPARATED : a cutting plane was generated +# * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start +# * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints +# * - SCIP_DIDNOTRUN : the separator was skipped +# * - SCIP_DELAYED : the separator was skipped, but should be called again +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSSEPASOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_SOL * sol , SCIP_RESULT * result ) /** constraint enforcing method of constraint handler for LP solutions +# * +# * The method is called at the end of the node processing loop for a node where the LP was solved. +# * The LP solution has to be checked for feasibility. If possible, an infeasibility should be resolved by +# * branching, reducing a variable's domain to exclude the solution or separating the solution with a valid +# * cutting plane. +# * +# * The enforcing methods of the active constraint handlers are called in decreasing order of their enforcing +# * priorities until the first constraint handler returned with the value SCIP_CUTOFF, SCIP_SEPARATED, +# * SCIP_REDUCEDDOM, SCIP_CONSADDED, or SCIP_BRANCHED. +# * The integrality constraint handler has an enforcing priority of zero. A constraint handler which can +# * (or wants) to enforce its constraints only for integral solutions should have a negative enforcing priority +# * (e.g. the alldiff-constraint can only operate on integral solutions). +# * A constraint handler which wants to incorporate its own branching strategy even on non-integral +# * solutions must have an enforcing priority greater than zero (e.g. the SOS-constraint incorporates +# * SOS-branching on non-integral solutions). +# * +# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing +# * method should process the useful constraints first. The other nconss - nusefulconss constraints should only +# * be enforced, if no violation was found in the useful constraints. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * - nusefulconss : number of useful (non-obsolete) constraints to process +# * - solinfeasible : was the solution already declared infeasible by a constraint handler? +# * - result : pointer to store the result of the enforcing call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_CONSADDED : an additional constraint was generated +# * - SCIP_REDUCEDDOM : a variable's domain was reduced +# * - SCIP_SEPARATED : a cutting plane was generated +# * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility +# * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved +# * - SCIP_FEASIBLE : all constraints of the handler are feasible +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSENFOLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_RESULT * result ) /** constraint enforcing method of constraint handler for relaxation solutions +# * +# * input: +# * - scip : SCIP main data structure +# * - sol : relaxation solution +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * - nusefulconss : number of useful (non-obsolete) constraints to process +# * - solinfeasible : was the solution already declared infeasible by a constraint handler? +# * - result : pointer to store the result of the enforcing call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_CONSADDED : an additional constraint was generated +# * - SCIP_REDUCEDDOM : a variable's domain was reduced +# * - SCIP_SEPARATED : a cutting plane was generated +# * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility +# * - SCIP_SOLVELP : at least one constraint is infeasible, and this can only be resolved by solving the LP +# * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved +# * - SCIP_FEASIBLE : all constraints of the handler are feasible +# * - SCIP_DIDNOTRUN : the enforcement was skipped (only possible, if objinfeasible is true) +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSENFORELAX ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SOL * sol , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_RESULT * result ) /** constraint enforcing method of constraint handler for pseudo solutions +# * +# * The method is called at the end of the node processing loop for a node where the LP was not solved. +# * The pseudo solution has to be checked for feasibility. If possible, an infeasibility should be resolved by +# * branching, reducing a variable's domain to exclude the solution or adding an additional constraint. +# * Separation is not possible, since the LP is not processed at the current node. All LP informations like +# * LP solution, slack values, or reduced costs are invalid and must not be accessed. +# * +# * Like in the enforcing method for LP solutions, the enforcing methods of the active constraint handlers are +# * called in decreasing order of their enforcing priorities until the first constraint handler returned with +# * the value SCIP_CUTOFF, SCIP_REDUCEDDOM, SCIP_CONSADDED, SCIP_BRANCHED, or SCIP_SOLVELP. +# * +# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing +# * method should process the useful constraints first. The other nconss - nusefulconss constraints should only +# * be enforced, if no violation was found in the useful constraints. +# * +# * If the pseudo solution's objective value is lower than the lower bound of the node, it cannot be feasible +# * and the enforcing method may skip it's check and set *result to SCIP_DIDNOTRUN. However, it can also process +# * its constraints and return any other possible result code. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * - nusefulconss : number of useful (non-obsolete) constraints to process +# * - solinfeasible : was the solution already declared infeasible by a constraint handler? +# * - objinfeasible : is the solution infeasible anyway due to violating lower objective bound? +# * - result : pointer to store the result of the enforcing call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_CONSADDED : an additional constraint was generated +# * - SCIP_REDUCEDDOM : a variable's domain was reduced +# * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility +# * - SCIP_SOLVELP : at least one constraint is infeasible, and this can only be resolved by solving the LP +# * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved +# * - SCIP_FEASIBLE : all constraints of the handler are feasible +# * - SCIP_DIDNOTRUN : the enforcement was skipped (only possible, if objinfeasible is true) +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSENFOPS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_Bool objinfeasible , SCIP_RESULT * result ) /** feasibility check method of constraint handler for integral solutions +# * +# * The given solution has to be checked for feasibility. +# * +# * The check methods of the active constraint handlers are called in decreasing order of their check +# * priorities until the first constraint handler returned with the result SCIP_INFEASIBLE. +# * The integrality constraint handler has a check priority of zero. A constraint handler which can +# * (or wants) to check its constraints only for integral solutions should have a negative check priority +# * (e.g. the alldiff-constraint can only operate on integral solutions). +# * A constraint handler which wants to check feasibility even on non-integral solutions must have a +# * check priority greater than zero (e.g. if the check is much faster than testing all variables for +# * integrality). +# * +# * In some cases, integrality conditions or rows of the current LP don't have to be checked, because their +# * feasibility is already checked or implicitly given. In these cases, 'checkintegrality' or +# * 'checklprows' is FALSE. +# * +# * If the solution is not NULL, SCIP should also be informed about the constraint violation with a call to +# * SCIPupdateSolConsViolation() and additionally SCIPupdateSolLPRowViolation() for every row of the constraint's current +# * representation in the LP relaxation, if any such rows exist. +# * As a convenience method, SCIPupdateSolLPConsViolation() can be used if the constraint +# * is represented completely by a set of LP rows, meaning that the current constraint violation is equal to the maximum +# * of the contraint violations of the corresponding LP rows. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * - sol : the solution to check feasibility for +# * - checkintegrality: Has integrality to be checked? +# * - checklprows : Do constraints represented by rows in the current LP have to be checked? +# * - printreason : Should the reason for the violation be printed? +# * - completely : Should all violations be checked? +# * - result : pointer to store the result of the feasibility checking call +# * +# * possible return values for *result: +# * - SCIP_INFEASIBLE : at least one constraint of the handler is infeasible +# * - SCIP_FEASIBLE : all constraints of the handler are feasible +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSCHECK ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_SOL * sol , SCIP_Bool checkintegrality , SCIP_Bool checklprows , SCIP_Bool printreason , SCIP_Bool completely , SCIP_RESULT * result ) /** domain propagation method of constraint handler +# * +# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The propagation +# * method should process only the useful constraints in most runs, and only occasionally the remaining +# * nconss - nusefulconss constraints. +# * +# * @note if the constraint handler uses dual information in propagation it is nesassary to check via calling +# * SCIPallowDualReds and SCIPallowObjProp if dual reductions and propgation with the current cutoff bound, resp., +# * are allowed. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * - nusefulconss : number of useful (non-obsolete) constraints to process +# * - nmarkedconss : number of constraints which are marked to be definitely propagated +# * - proptiming : current point in the node solving loop +# * - result : pointer to store the result of the propagation call +# * +# * possible return values for *result: +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_REDUCEDDOM : at least one domain reduction was found +# * - SCIP_DIDNOTFIND : the propagator searched but did not find any domain reductions +# * - SCIP_DIDNOTRUN : the propagator was skipped +# * - SCIP_DELAYED : the propagator was skipped, but should be called again +# * - SCIP_DELAYNODE : the current node should be postponed (return value only valid for BEFORELP propagation) +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , int nmarkedconss , SCIP_PROPTIMING proptiming , SCIP_RESULT * result ) /** presolving method of constraint handler +# * +# * The presolver should go through the variables and constraints and tighten the domains or +# * constraints. Each tightening should increase the given total number of changes. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints to process +# * - nconss : number of constraints to process +# * - nrounds : number of presolving rounds already done +# * - presoltiming : current presolving timing +# * - nnewfixedvars : number of variables fixed since the last call to the presolving method +# * - nnewaggrvars : number of variables aggregated since the last call to the presolving method +# * - nnewchgvartypes : number of variable type changes since the last call to the presolving method +# * - nnewchgbds : number of variable bounds tightened since the last call to the presolving method +# * - nnewholes : number of domain holes added since the last call to the presolving method +# * - nnewdelconss : number of deleted constraints since the last call to the presolving method +# * - nnewaddconss : number of added constraints since the last call to the presolving method +# * - nnewupgdconss : number of upgraded constraints since the last call to the presolving method +# * - nnewchgcoefs : number of changed coefficients since the last call to the presolving method +# * - nnewchgsides : number of changed left or right hand sides since the last call to the presolving method +# * +# * @note the counters state the changes since the last call including the changes of this presolving method during its +# * call +# * +# * @note if the constraint handler performs dual presolving it is nesassary to check via calling SCIPallowDualReds +# * if dual reductions are allowed. +# * +# * input/output: +# * - nfixedvars : pointer to count total number of variables fixed of all presolvers +# * - naggrvars : pointer to count total number of variables aggregated of all presolvers +# * - nchgvartypes : pointer to count total number of variable type changes of all presolvers +# * - nchgbds : pointer to count total number of variable bounds tightened of all presolvers +# * - naddholes : pointer to count total number of domain holes added of all presolvers +# * - ndelconss : pointer to count total number of deleted constraints of all presolvers +# * - naddconss : pointer to count total number of added constraints of all presolvers +# * - nupgdconss : pointer to count total number of upgraded constraints of all presolvers +# * - nchgcoefs : pointer to count total number of changed coefficients of all presolvers +# * - nchgsides : pointer to count total number of changed left/right hand sides of all presolvers +# * +# * output: +# * - result : pointer to store the result of the presolving call +# * +# * possible return values for *result: +# * - SCIP_UNBOUNDED : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded +# * - SCIP_CUTOFF : at least one constraint is infeasible in the variable's bounds -> problem is infeasible +# * - SCIP_SUCCESS : the presolving method found a reduction +# * - SCIP_DIDNOTFIND : the presolving method searched, but did not find a presolving change +# * - SCIP_DIDNOTRUN : the presolving method was skipped +# * - SCIP_DELAYED : the presolving method was skipped, but should be called again +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSPRESOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) /** propagation conflict resolving method of constraint handler +# * +# * This method is called during conflict analysis. If the constraint handler wants to support conflict analysis, +# * it should call SCIPinferVarLbCons() or SCIPinferVarUbCons() in domain propagation instead of SCIPchgVarLb() or +# * SCIPchgVarUb() in order to deduce bound changes on variables. +# * In the SCIPinferVarLbCons() and SCIPinferVarUbCons() calls, the handler provides the constraint, that deduced the +# * variable's bound change, and an integer value "inferinfo" that can be arbitrarily chosen. +# * The propagation conflict resolving method can then be implemented, to provide a "reason" for the bound +# * changes, i.e., the bounds of variables at the time of the propagation, that forced the constraint to set the +# * conflict variable's bound to its current value. It can use the "inferinfo" tag to identify its own propagation +# * rule and thus identify the "reason" bounds. The bounds that form the reason of the assignment must then be provided +# * by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), +# * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and/or SCIPaddConflictBinvar() in the propagation conflict +# * resolving method. +# * +# * For example, the logicor constraint c = "x or y or z" fixes variable z to TRUE (i.e. changes the lower bound of z +# * to 1.0), if both, x and y, are assigned to FALSE (i.e. if the upper bounds of these variables are 0.0). It uses +# * SCIPinferVarLbCons(scip, z, 1.0, c, 0) to apply this assignment (an inference information tag is not needed by the +# * constraint handler and is set to 0). +# * In the conflict analysis, the constraint handler may be asked to resolve the lower bound change on z with +# * constraint c, that was applied at a time given by a bound change index "bdchgidx". +# * With a call to SCIPgetVarLbAtIndex(scip, z, bdchgidx, TRUE), the handler can find out, that the lower bound of +# * variable z was set to 1.0 at the given point of time, and should call SCIPaddConflictUb(scip, x, bdchgidx) and +# * SCIPaddConflictUb(scip, y, bdchgidx) to tell SCIP, that the upper bounds of x and y at this point of time were +# * the reason for the deduction of the lower bound of z. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint that deduced the bound change of the conflict variable +# * - infervar : the conflict variable whose bound change has to be resolved +# * - inferinfo : the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call +# * - boundtype : the type of the changed bound (lower or upper bound) +# * - bdchgidx : the index of the bound change, representing the point of time where the change took place +# * - relaxedbd : the relaxed bound which is sufficient to be explained +# * +# * output: +# * - result : pointer to store the result of the propagation conflict resolving call +# * +# * possible return values for *result: +# * - SCIP_SUCCESS : the conflicting bound change has been successfully resolved by adding all reason bounds +# * - SCIP_DIDNOTFIND : the conflicting bound change could not be resolved and has to be put into the conflict set +# * +# * @note it is sufficient to explain/resolve the relaxed bound +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSRESPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_VAR * infervar , int inferinfo , SCIP_BOUNDTYPE boundtype , SCIP_BDCHGIDX * bdchgidx , SCIP_Real relaxedbd , SCIP_RESULT * result ) /** variable rounding lock method of constraint handler +# * +# * This method is called, after a constraint is added or removed from the transformed problem. +# * It should update the rounding locks of the given type of all associated variables with calls to +# * SCIPaddVarLocksType(), depending on the way, the variable is involved in the constraint: +# * - If the constraint may get violated by decreasing the value of a variable, it should call +# * SCIPaddVarLocksType(scip, var, locktype, nlockspos, nlocksneg), saying that rounding down is +# * potentially rendering the (positive) constraint infeasible and rounding up is potentially rendering the +# * negation of the constraint infeasible. +# * - If the constraint may get violated by increasing the value of a variable, it should call +# * SCIPaddVarLocksType(scip, var, locktype, nlocksneg, nlockspos), saying that rounding up is +# * potentially rendering the constraint's negation infeasible and rounding up is potentially rendering the +# * constraint itself infeasible. +# * - If the constraint may get violated by changing the variable in any direction, it should call +# * SCIPaddVarLocksType(scip, var, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg). +# * +# * Consider the linear constraint "3x -5y +2z <= 7" as an example. The variable rounding lock method of the +# * linear constraint handler should call SCIPaddVarLocksType(scip, x, locktype, nlocksneg, nlockspos), +# * SCIPaddVarLocksType(scip, y, locktype, nlockspos, nlocksneg) and +# * SCIPaddVarLocksType(scip, z, type, nlocksneg, nlockspos) to tell SCIP, that rounding up of x and z and rounding +# * down of y can destroy the feasibility of the constraint, while rounding down of x and z and rounding up of y can +# * destroy the feasibility of the constraint's negation "3x -5y +2z > 7". +# * A linear constraint "2 <= 3x -5y +2z <= 7" should call +# * SCIPaddVarLocksType(scip, ..., nlockspos + nlocksneg, nlockspos + nlocksneg) on all variables, since rounding in both +# * directions of each variable can destroy both the feasibility of the constraint and it's negation +# * "3x -5y +2z < 2 or 3x -5y +2z > 7". +# * +# * If the constraint itself contains other constraints as sub constraints (e.g. the "or" constraint concatenation +# * "c(x) or d(x)"), the rounding lock methods of these constraints should be called in a proper way. +# * - If the constraint may get violated by the violation of the sub constraint c, it should call +# * SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg), saying that infeasibility of c may lead to +# * infeasibility of the (positive) constraint, and infeasibility of c's negation (i.e. feasibility of c) may lead +# * to infeasibility of the constraint's negation (i.e. feasibility of the constraint). +# * - If the constraint may get violated by the feasibility of the sub constraint c, it should call +# * SCIPaddConsLocksType(scip, c, locktype, nlocksneg, nlockspos), saying that infeasibility of c may lead to +# * infeasibility of the constraint's negation (i.e. feasibility of the constraint), and infeasibility of c's negation +# * (i.e. feasibility of c) may lead to infeasibility of the (positive) constraint. +# * - If the constraint may get violated by any change in the feasibility of the sub constraint c, it should call +# * SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg). +# * +# * Consider the or concatenation "c(x) or d(x)". The variable rounding lock method of the or constraint handler +# * should call SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg) and +# * SCIPaddConsLocksType(scip, d, locktype, nlockspos, nlocksneg) to tell SCIP, that infeasibility of c and d can lead +# * to infeasibility of "c(x) or d(x)". +# * +# * As a second example, consider the equivalence constraint "y <-> c(x)" with variable y and constraint c. The +# * constraint demands, that y == 1 if and only if c(x) is satisfied. The variable lock method of the corresponding +# * constraint handler should call SCIPaddVarLocksType(scip, y, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg) and +# * SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg), because any modification to the +# * value of y or to the feasibility of c can alter the feasibility of the equivalence constraint. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint that should lock rounding of its variables, or NULL if the constraint handler +# * does not need constraints +# * - locktype : type of rounding locks, i.e., SCIP_LOCKTYPE_MODEL or SCIP_LOCKTYPE_CONFLICT +# * - nlockspos : number of times, the roundings should be locked for the constraint (may be negative) +# * - nlocksneg : number of times, the roundings should be locked for the constraint's negation (may be negative) +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSLOCK ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_LOCKTYPE locktype , int nlockspos , int nlocksneg ) /** constraint activation notification method of constraint handler +# * +# * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but +# * the corresponding bound change event was not yet processed. +# * +# * This method is always called after a constraint of the constraint handler was activated. The constraint +# * handler may use this call to update his own (statistical) data. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint that has been activated +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSACTIVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) /** constraint deactivation notification method of constraint handler +# * +# * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but +# * the corresponding bound change event was not yet processed. +# * +# * This method is always called before a constraint of the constraint handler is deactivated. The constraint +# * handler may use this call to update his own (statistical) data. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint that will be deactivated +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSDEACTIVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) /** constraint enabling notification method of constraint handler +# * +# * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but +# * the corresponding bound change event was not yet processed. +# * +# * This method is always called after a constraint of the constraint handler was enabled. The constraint +# * handler may use this call to update his own (statistical) data. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint that has been enabled +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSENABLE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) /** constraint disabling notification method of constraint handler +# * +# * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but +# * the corresponding bound change event was not yet processed. +# * +# * This method is always called before a constraint of the constraint handler is disabled. The constraint +# * handler may use this call to update his own (statistical) data. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint that will be disabled +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSDISABLE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) /** variable deletion method of constraint handler +# * +# * This method is optinal and only of interest if you are using SCIP as a branch-and-price framework. That means, you +# * are generating new variables during the search. If you are not doing that just define the function pointer to be +# * NULL. +# * +# * If this method gets implemented you should iterate over all constraints of the constraint handler and delete all +# * variables that were marked for deletion by SCIPdelVar(). +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - conss : array of constraints in transformed problem +# * - nconss : number of constraints in transformed problem +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSDELVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** constraint display method of constraint handler +# * +# * The constraint handler can store a representation of the constraint into the given text file. Use the method +# * SCIPinfoMessage() to push a string into the file stream. +# * +# * @note There are several methods which help to display variables. These are SCIPwriteVarName(), SCIPwriteVarsList(), +# * SCIPwriteVarsLinearsum(), and SCIPwriteVarsPolynomial(). +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint that should be displayed +# * - file : the text file to store the information into +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSPRINT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , FILE * file ) /** constraint copying method of constraint handler +# * +# * The constraint handler can provide a copy method which copies a constraint from one SCIP data structure into an other +# * SCIP data structure. If a copy of a constraint is created, the constraint has to be captured. (The capture is usually +# * already done due to the creation of the constraint). +# * +# * If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, you have to set this pointer to +# * FALSE. In case all problem defining objects (constraint handlers and variable pricers) return a TRUE valid for all +# * their copying calls, SCIP assumes that it is a overall one to one copy of the original instance. In this case any +# * reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is +# * set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off. +# * +# * To get a copy of a variable in the target SCIP you should use the function SCIPgetVarCopy(). +# * +# * input: +# * - scip : target SCIP data structure +# * - cons : pointer to store the created target constraint +# * - name : name of constraint, or NULL if the name of the source constraint should be used +# * - sourcescip : source SCIP data structure +# * - sourceconshdlr : source constraint handler of the source SCIP +# * - sourcecons : source constraint of the source SCIP +# * - varmap : a SCIP_HASHMAP mapping variables of the source SCIP to corresponding variables of the target SCIP +# * - consmap : a SCIP_HASHMAP mapping constraints of the source SCIP to corresponding constraints of the target SCIP +# * - initial : should the LP relaxation of constraint be in the initial LP? +# * - separate : should the constraint be separated during LP processing? +# * - enforce : should the constraint be enforced during node processing? +# * - check : should the constraint be checked for feasibility? +# * - propagate : should the constraint be propagated during node processing? +# * - local : is constraint only valid locally? +# * - modifiable : is constraint modifiable (subject to column generation)? +# * - dynamic : is constraint subject to aging? +# * - removable : should the relaxation be removed from the LP due to aging or cleanup? +# * - stickingatnode : should the constraint always be kept at the node where it was added, even +# * if it may be moved to a more global node? +# * - global : should a global or a local copy be created? +# * +# * output: +# * - valid : pointer to store whether the copying was valid or not +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONS * * cons , const char * name , SCIP * sourcescip , SCIP_CONSHDLR * sourceconshdlr , SCIP_CONS * sourcecons , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_Bool initial , SCIP_Bool separate , SCIP_Bool enforce , SCIP_Bool check , SCIP_Bool propagate , SCIP_Bool local , SCIP_Bool modifiable , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool stickingatnode , SCIP_Bool global , SCIP_Bool * valid ) /** constraint parsing method of constraint handler +# * +# * The constraint handler can provide a callback to parse the output created by the display method +# * (\ref SCIP_DECL_CONSPRINT) and to create a constraint out of it. +# * +# * @note For parsing there are several methods which are handy. Have a look at: SCIPparseVarName(), +# * SCIPparseVarsList(), SCIPparseVarsLinearsum(), SCIPparseVarsPolynomial(), SCIPstrToRealValue(), and +# * SCIPstrCopySection(). +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : pointer to store the created constraint +# * - name : name of the constraint +# * - str : string to parse +# * - initial : should the LP relaxation of constraint be in the initial LP? +# * - separate : should the constraint be separated during LP processing? +# * - enforce : should the constraint be enforced during node processing? +# * - check : should the constraint be checked for feasibility? +# * - propagate : should the constraint be propagated during node processing? +# * - local : is constraint only valid locally? +# * - modifiable : is constraint modifiable (subject to column generation)? +# * - dynamic : is constraint subject to aging? +# * - removable : should the relaxation be removed from the LP due to aging or cleanup? +# * - stickingatnode : should the constraint always be kept at the node where it was added, even +# * if it may be moved to a more global node? +# * output: +# * - success : pointer to store whether the parsing was successful or not +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSPARSE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * cons , const char * name , const char * str , SCIP_Bool initial , SCIP_Bool separate , SCIP_Bool enforce , SCIP_Bool check , SCIP_Bool propagate , SCIP_Bool local , SCIP_Bool modifiable , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool stickingatnode , SCIP_Bool * success ) /** constraint method of constraint handler which returns the variables (if possible) +# * +# * The constraint handler can (this callback is optional) provide this callback to return the variables which are +# * involved in that particular constraint. If this is possible, the variables should be copyied into the variables +# * array and the success pointers has to be set to TRUE. Otherwise the success has to be set FALSE or the callback +# * should not be implemented. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : the constraint that should return its variable data +# * - varssize : available slots in vars array which is needed to check if the array is large enough +# * +# * output: +# * - vars : array to store/copy the involved variables of the constraint +# * - success : pointer to store whether the variables are successfully copied +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSGETVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_VAR * * vars , int varssize , SCIP_Bool * success ) /** constraint method of constraint handler which returns the number of variables (if possible) +# * +# * The constraint handler can (this callback is optional) provide this callback to return the number variable which are +# * involved in that particular constraint. If this is not possible, the success pointers has to be set to FALSE or the +# * callback should not be implemented. +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - cons : constraint for which the number of variables is wanted +# * +# * output: +# * - nvars : pointer to store the number of variables +# * - success : pointer to store whether the constraint successfully returned the number of variables +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSGETNVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , int * nvars , SCIP_Bool * success ) /** constraint handler method to suggest dive bound changes during the generic diving algorithm +# * +# * This callback is used inside the various diving heuristics of SCIP and does not affect the normal branching of the +# * actual search. The constraint handler can provide this callback to render the current solution (even more) +# * infeasible by suggesting one or several variable bound changes. In fact, since diving heuristics do not necessarily +# * solve LP relaxations at every probing depth, some of the variable local bounds might already be conflicting with the +# * solution values. The solution is rendered infeasible by determining bound changes that should be applied to the +# * next explored search node via SCIPaddDiveBoundChange(). An alternative in case that the preferred bound change(s) +# * were detected infeasible must be provided. +# * +# * The constraint handler must take care to only add bound changes that further shrink the variable domain. +# * +# * The success pointer must be used to indicate whether the constraint handler succeeded in selecting diving bound +# * changes. The infeasible pointer should be set to TRUE if the constraint handler found a local infeasibility. If the +# * constraint handler needs to select between several candidates, it may use the scoring mechanism of the diveset +# * argument to control its choice. +# * +# * This callback is optional. +# * +# * @note: @p sol is usually the LP relaxation solution unless the caller of the method, usually a diving heuristic, +# * does not solve LP relaxations at every depth +# * +# * input: +# * - scip : SCIP main data structure +# * - conshdlr : the constraint handler itself +# * - diveset : diving settings for scoring +# * - sol : current diving solution, usually the LP relaxation solution +# * +# * output: +# * - success : pointer to store whether the constraint handler succeeded to determine dive bound changes +# * - infeasible : pointer to store whether the constraint handler detected an infeasibility in the local node +# */ +# Skipping MacroDefinition: SCIP_DECL_CONSGETDIVEBDCHGS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_DIVESET * diveset , SCIP_SOL * sol , SCIP_Bool * success , SCIP_Bool * infeasible ) # + +struct SCIP_Conshdlr +end + +const SCIP_CONSHDLR = Cvoid + +struct SCIP_Cons +end + +const SCIP_CONS = Cvoid + +struct SCIP_ConshdlrData +end + +const SCIP_CONSHDLRDATA = Cvoid + +struct SCIP_ConsData +end + +const SCIP_CONSDATA = Cvoid + +struct SCIP_ConsSetChg +end + +const SCIP_CONSSETCHG = Cvoid + +struct SCIP_LinConsStats +end + +const SCIP_LINCONSSTATS = Cvoid + +# begin enum SCIP_LinConstype +const SCIP_LinConstype = UInt32 +const SCIP_LINCONSTYPE_EMPTY = 0 |> UInt32 +const SCIP_LINCONSTYPE_FREE = 1 |> UInt32 +const SCIP_LINCONSTYPE_SINGLETON = 2 |> UInt32 +const SCIP_LINCONSTYPE_AGGREGATION = 3 |> UInt32 +const SCIP_LINCONSTYPE_PRECEDENCE = 4 |> UInt32 +const SCIP_LINCONSTYPE_VARBOUND = 5 |> UInt32 +const SCIP_LINCONSTYPE_SETPARTITION = 6 |> UInt32 +const SCIP_LINCONSTYPE_SETPACKING = 7 |> UInt32 +const SCIP_LINCONSTYPE_SETCOVERING = 8 |> UInt32 +const SCIP_LINCONSTYPE_CARDINALITY = 9 |> UInt32 +const SCIP_LINCONSTYPE_INVKNAPSACK = 10 |> UInt32 +const SCIP_LINCONSTYPE_EQKNAPSACK = 11 |> UInt32 +const SCIP_LINCONSTYPE_BINPACKING = 12 |> UInt32 +const SCIP_LINCONSTYPE_KNAPSACK = 13 |> UInt32 +const SCIP_LINCONSTYPE_INTKNAPSACK = 14 |> UInt32 +const SCIP_LINCONSTYPE_MIXEDBINARY = 15 |> UInt32 +const SCIP_LINCONSTYPE_GENERAL = 16 |> UInt32 +# end enum SCIP_LinConstype + +const SCIP_LINCONSTYPE = SCIP_LinConstype + +struct SCIP_Cutpool +end + +const SCIP_CUTPOOL = Cvoid + +struct SCIP_Cut +end + +const SCIP_CUT = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_DIALOGCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) /** destructor of dialog to free user data (called when the dialog is not captured anymore) +# * +# * input: +# * - scip : SCIP main data structure +# * - dialog : the dialog itself +# */ +# Skipping MacroDefinition: SCIP_DECL_DIALOGFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) /** description output method of dialog +# * +# * This method should output (usually a single line of) information describing the meaning of the dialog. +# * The method is called, when the help menu of the parent's dialog is displayed. +# * If no description output method is given, the description string of the dialog is displayed instead. +# * +# * input: +# * - scip : SCIP main data structure +# * - *dialog : the dialog itself +# */ +# Skipping MacroDefinition: SCIP_DECL_DIALOGDESC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) /** execution method of dialog +# * +# * This method is invoked, if the user selected the dialog's command name in the parent's dialog menu. +# * +# * input: +# * - scip : SCIP main data structure +# * - dialoghdlr : dialog handler to call for user interaction +# * - dialog : the dialog itself +# * +# * output: +# * - *nextdialog : next dialog to process (or NULL to quit dialog processing) +# */ +# Skipping MacroDefinition: SCIP_DECL_DIALOGEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog , SCIP_DIALOGHDLR * dialoghdlr , SCIP_DIALOG * * nextdialog ) # + +struct SCIP_Dialog +end + +const SCIP_DIALOG = Cvoid + +struct SCIP_DialogData +end + +const SCIP_DIALOGDATA = Cvoid + +struct SCIP_Dialoghdlr +end + +const SCIP_DIALOGHDLR = Cvoid + +struct SCIP_Linelist +end + +const SCIP_LINELIST = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_DISPCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** destructor of display column to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - disp : the display column itself +# */ +# Skipping MacroDefinition: SCIP_DECL_DISPFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** initialization method of display column (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - disp : the display column itself +# */ +# Skipping MacroDefinition: SCIP_DECL_DISPINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** deinitialization method of display column (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - disp : the display column itself +# */ +# Skipping MacroDefinition: SCIP_DECL_DISPEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** solving process initialization method of display column (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The display column may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - disp : the display column itself +# */ +# Skipping MacroDefinition: SCIP_DECL_DISPINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** solving process deinitialization method of display column (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The display column should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - disp : the display column itself +# */ +# Skipping MacroDefinition: SCIP_DECL_DISPEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** output method of display column to output file stream 'file' +# * +# * input: +# * - scip : SCIP main data structure +# * - disp : the display column itself +# * - file : file stream for output +# */ +# Skipping MacroDefinition: SCIP_DECL_DISPOUTPUT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp , FILE * file ) # + +# begin enum SCIP_DispStatus +const SCIP_DispStatus = UInt32 +const SCIP_DISPSTATUS_OFF = 0 |> UInt32 +const SCIP_DISPSTATUS_AUTO = 1 |> UInt32 +const SCIP_DISPSTATUS_ON = 2 |> UInt32 +# end enum SCIP_DispStatus + +const SCIP_DISPSTATUS = SCIP_DispStatus + +# begin enum SCIP_DispMode +const SCIP_DispMode = UInt32 +const SCIP_DISPMODE_DEFAULT = 1 |> UInt32 +const SCIP_DISPMODE_CONCURRENT = 2 |> UInt32 +const SCIP_DISPMODE_ALL = 3 |> UInt32 +# end enum SCIP_DispMode + +const SCIP_DISPMODE = SCIP_DispMode + +struct SCIP_Disp +end + +const SCIP_DISP = Cvoid + +struct SCIP_DispData +end + +const SCIP_DISPDATA = Cvoid +const SCIP_DIVETYPE_NONE = UInt32(0x0000) +const SCIP_DIVETYPE_INTEGRALITY = UInt32(0x0001) +const SCIP_DIVETYPE_SOS1VARIABLE = UInt32(0x0002) + +# Skipping MacroDefinition: SCIP_DECL_HEURCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** destructor of primal heuristic to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - heur : the primal heuristic itself +# */ +# Skipping MacroDefinition: SCIP_DECL_HEURFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** initialization method of primal heuristic (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - heur : the primal heuristic itself +# */ +# Skipping MacroDefinition: SCIP_DECL_HEURINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** deinitialization method of primal heuristic (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - heur : the primal heuristic itself +# */ +# Skipping MacroDefinition: SCIP_DECL_HEUREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** solving process initialization method of primal heuristic (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The primal heuristic may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - heur : the primal heuristic itself +# */ +# Skipping MacroDefinition: SCIP_DECL_HEURINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** solving process deinitialization method of primal heuristic (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The primal heuristic should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - heur : the primal heuristic itself +# */ +# Skipping MacroDefinition: SCIP_DECL_HEUREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** execution method of primal heuristic +# * +# * Searches for feasible primal solutions. The method is called in the node processing loop. +# * +# * input: +# * - scip : SCIP main data structure +# * - heur : the primal heuristic itself +# * - heurtiming : current point in the node solving loop +# * - nodeinfeasible : was the current node already detected to be infeasible? +# * - result : pointer to store the result of the heuristic call +# * +# * possible return values for *result: +# * - SCIP_FOUNDSOL : at least one feasible primal solution was found +# * - SCIP_DIDNOTFIND : the heuristic searched, but did not find a feasible solution +# * - SCIP_DIDNOTRUN : the heuristic was skipped +# * - SCIP_DELAYED : the heuristic was skipped, but should be called again as soon as possible, disregarding +# * its frequency +# */ +# Skipping MacroDefinition: SCIP_DECL_HEUREXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur , SCIP_HEURTIMING heurtiming , SCIP_Bool nodeinfeasible , SCIP_RESULT * result ) /* callbacks for diving heuristic specific settings */ +# Skipping MacroDefinition: SCIP_DECL_DIVESETGETSCORE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIVESET * diveset , SCIP_DIVETYPE divetype , SCIP_VAR * cand , SCIP_Real candsol , SCIP_Real candsfrac , SCIP_Real * score , SCIP_Bool * roundup ) # + +const SCIP_DIVETYPE = UInt32 + +struct SCIP_Heur +end + +const SCIP_HEUR = Cvoid + +struct SCIP_HeurData +end + +const SCIP_HEURDATA = Cvoid + +struct SCIP_Diveset +end + +const SCIP_DIVESET = Cvoid + +struct SCIP_VGraph +end + +const SCIP_VGRAPH = Cvoid + +# begin enum SCIP_BranchDir +const SCIP_BranchDir = UInt32 +const SCIP_BRANCHDIR_DOWNWARDS = 0 |> UInt32 +const SCIP_BRANCHDIR_UPWARDS = 1 |> UInt32 +const SCIP_BRANCHDIR_FIXED = 2 |> UInt32 +const SCIP_BRANCHDIR_AUTO = 3 |> UInt32 +# end enum SCIP_BranchDir + +const SCIP_BRANCHDIR = SCIP_BranchDir + +struct SCIP_History +end + +const SCIP_HISTORY = Cvoid + +struct SCIP_ValueHistory +end + +const SCIP_VALUEHISTORY = Cvoid + +struct SCIP_VBounds +end + +const SCIP_VBOUNDS = Cvoid + +struct SCIP_Implics +end + +const SCIP_IMPLICS = Cvoid + +struct SCIP_Clique +end + +const SCIP_CLIQUE = Cvoid + +struct SCIP_CliqueTable +end + +const SCIP_CLIQUETABLE = Cvoid + +struct SCIP_CliqueList +end + +const SCIP_CLIQUELIST = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_MESSAGEOUTPUTFUNC ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) /** error message print method +# * +# * This method is invoked, if SCIP wants to display an error message to the screen or a file. +# * +# * @note This function is independent of any message handler. +# * +# * input: +# * - data : data pointer +# * - file : file stream to print into +# * - msg : string to output into the file (or NULL to flush) +# */ +# Skipping MacroDefinition: SCIP_DECL_ERRORPRINTING ( x ) void x ( void * data , FILE * file , const char * msg ) /** warning message print method of message handler +# * +# * This method is invoked, if SCIP wants to display a warning message to the screen or a file. +# * +# * input: +# * - messagehdlr : the message handler itself +# * - file : file stream to print into +# * - msg : string to output into the file (or NULL to flush) +# */ +# Skipping MacroDefinition: SCIP_DECL_MESSAGEWARNING ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) /** dialog message print method of message handler +# * +# * This method is invoked, if SCIP wants to display a dialog message to the screen or a file. +# * +# * input: +# * - messagehdlr : the message handler itself +# * - file : file stream to print into +# * - msg : string to output into the file (or NULL to flush) +# */ +# Skipping MacroDefinition: SCIP_DECL_MESSAGEDIALOG ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) /** info message print method of message handler +# * +# * This method is invoked, if SCIP wants to display an information message to the screen or a file. +# * +# * input: +# * - messagehdlr : the message handler itself +# * - file : file stream to print into +# * - msg : string to output into the file (or NULL to flush) +# */ +# Skipping MacroDefinition: SCIP_DECL_MESSAGEINFO ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) /** destructor of message handler to free message handler data +# * +# * This method is invoked, if SCIP wants to free a message handler. +# * +# * input: +# * - messagehdlr : the message handler itself +# */ +# Skipping MacroDefinition: SCIP_DECL_MESSAGEHDLRFREE ( x ) SCIP_RETCODE x ( SCIP_MESSAGEHDLR * messagehdlr ) # + +# begin enum SCIP_VerbLevel +const SCIP_VerbLevel = UInt32 +const SCIP_VERBLEVEL_NONE = 0 |> UInt32 +const SCIP_VERBLEVEL_DIALOG = 1 |> UInt32 +const SCIP_VERBLEVEL_MINIMAL = 2 |> UInt32 +const SCIP_VERBLEVEL_NORMAL = 3 |> UInt32 +const SCIP_VERBLEVEL_HIGH = 4 |> UInt32 +const SCIP_VERBLEVEL_FULL = 5 |> UInt32 +# end enum SCIP_VerbLevel + +const SCIP_VERBLEVEL = SCIP_VerbLevel + +struct SCIP_Messagehdlr +end + +const SCIP_MESSAGEHDLR = Cvoid + +struct SCIP_MessagehdlrData +end + +const SCIP_MESSAGEHDLRDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_NODESELCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** destructor of node selector to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - nodesel : the node selector itself +# */ +# Skipping MacroDefinition: SCIP_DECL_NODESELFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** initialization method of node selector (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - nodesel : the node selector itself +# */ +# Skipping MacroDefinition: SCIP_DECL_NODESELINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** deinitialization method of node selector (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - nodesel : the node selector itself +# */ +# Skipping MacroDefinition: SCIP_DECL_NODESELEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** solving process initialization method of node selector (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The node selector may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - nodesel : the node selector itself +# */ +# Skipping MacroDefinition: SCIP_DECL_NODESELINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** solving process deinitialization method of node selector (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The node selector should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - nodesel : the node selector itself +# */ +# Skipping MacroDefinition: SCIP_DECL_NODESELEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** node selection method of node selector +# * +# * This method is called to select the next leaf of the branch and bound tree to be processed. +# * +# * input: +# * - scip : SCIP main data structure +# * - nodesel : the node selector itself +# * - selnode : pointer to store the selected node +# * +# * possible return values for *selnode: +# * - NULL : problem is solved, because tree is empty +# * - non-NULL: node to be solved next +# */ +# Skipping MacroDefinition: SCIP_DECL_NODESELSELECT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel , SCIP_NODE * * selnode ) /** node comparison method of node selector +# * +# * This method is called to compare two nodes regarding their order in the node priority queue. +# * +# * input: +# * - scip : SCIP main data structure +# * - nodesel : the node selector itself +# * - node1 : first node to compare +# * - node2 : second node to compare +# * +# * possible return values: +# * - value < 0: node1 comes before (is better than) node2 +# * - value = 0: both nodes are equally good +# * - value > 0: node2 comes after (is worse than) node2 +# */ +# Skipping MacroDefinition: SCIP_DECL_NODESELCOMP ( x ) int x ( SCIP * scip , SCIP_NODESEL * nodesel , SCIP_NODE * node1 , SCIP_NODE * node2 ) # + +struct SCIP_NodePQ +end + +const SCIP_NODEPQ = Cvoid + +struct SCIP_Nodesel +end + +const SCIP_NODESEL = Cvoid + +struct SCIP_NodeselData +end + +const SCIP_NODESELDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_PRESOLCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** destructor of presolver to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - presol : the presolver itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRESOLFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** initialization method of presolver (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - presol : the presolver itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRESOLINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** deinitialization method of presolver (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - presol : the presolver itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRESOLEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** presolving initialization method of presolver (called when presolving is about to begin) +# * +# * This method is called when the presolving process is about to begin, even if presolving is turned off. +# * The presolver may use this call to initialize its data structures. +# * +# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the +# * presolving deinitialization call (SCIP_DECL_PRESOLSEXITPRE()). +# * +# * input: +# * - scip : SCIP main data structure +# * - presol : the presolver itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRESOLINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** presolving deinitialization method of presolver (called after presolving has been finished) +# * +# * This method is called after the presolving has been finished, even if presolving is turned off. +# * The presolver may use this call e.g. to clean up or modify its data structures. +# * +# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the +# * presolving initialization call (SCIP_DECL_PRESOLINITPRE()). +# * +# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the +# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, +# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. +# * +# * input: +# * - scip : SCIP main data structure +# * - presol : the presolver itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRESOLEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** execution method of presolver +# * +# * The presolver should go through the variables and constraints and tighten the domains or +# * constraints. Each tightening should increase the given total numbers of changes. +# * +# * input: +# * - scip : SCIP main data structure +# * - presol : the presolver itself +# * - nrounds : number of presolving rounds already done +# * - presoltiming : current presolving timing +# * - nnewfixedvars : number of variables fixed since the last call to the presolver +# * - nnewaggrvars : number of variables aggregated since the last call to the presolver +# * - nnewchgvartypes : number of variable type changes since the last call to the presolver +# * - nnewchgbds : number of variable bounds tightened since the last call to the presolver +# * - nnewholes : number of domain holes added since the last call to the presolver +# * - nnewdelconss : number of deleted constraints since the last call to the presolver +# * - nnewaddconss : number of added constraints since the last call to the presolver +# * - nnewupgdconss : number of upgraded constraints since the last call to the presolver +# * - nnewchgcoefs : number of changed coefficients since the last call to the presolver +# * - nnewchgsides : number of changed left or right hand sides since the last call to the presolver +# * +# * @note the counters state the changes since the last call including the changes of this presolver during its last +# * last call +# * +# * @note if the presolver uses dual information it is nesassary to check via calling SCIPallowDualReds if dual +# * reductions are allowed. +# * +# * input/output: +# * - nfixedvars : pointer to total number of variables fixed of all presolvers +# * - naggrvars : pointer to total number of variables aggregated of all presolvers +# * - nchgvartypes : pointer to total number of variable type changes of all presolvers +# * - nchgbds : pointer to total number of variable bounds tightened of all presolvers +# * - naddholes : pointer to total number of domain holes added of all presolvers +# * - ndelconss : pointer to total number of deleted constraints of all presolvers +# * - naddconss : pointer to total number of added constraints of all presolvers +# * - nupgdconss : pointer to total number of upgraded constraints of all presolvers +# * - nchgcoefs : pointer to total number of changed coefficients of all presolvers +# * - nchgsides : pointer to total number of changed left/right hand sides of all presolvers +# * +# * output: +# * - result : pointer to store the result of the presolving call +# * +# * possible return values for *result: +# * - SCIP_UNBOUNDED : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded +# * - SCIP_CUTOFF : at least one constraint is infeasible in the variable's bounds -> problem is infeasible +# * - SCIP_SUCCESS : the presolver found a reduction +# * - SCIP_DIDNOTFIND : the presolver searched, but did not find a presolving change +# * - SCIP_DIDNOTRUN : the presolver was skipped +# */ +# Skipping MacroDefinition: SCIP_DECL_PRESOLEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) # + +struct SCIP_Presol +end + +const SCIP_PRESOL = Cvoid + +struct SCIP_PresolData +end + +const SCIP_PRESOLDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_PRICERCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_Bool * valid ) /** destructor of variable pricer to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - pricer : the variable pricer itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRICERFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** initialization method of variable pricer (called after problem was transformed and pricer is active) +# * +# * input: +# * - scip : SCIP main data structure +# * - pricer : the variable pricer itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRICERINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** deinitialization method of variable pricer (called before transformed problem is freed and pricer is active) +# * +# * input: +# * - scip : SCIP main data structure +# * - pricer : the variable pricer itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRICEREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** solving process initialization method of variable pricer (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The variable pricer may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - pricer : the variable pricer itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRICERINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** solving process deinitialization method of variable pricer (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The variable pricer should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - pricer : the variable pricer itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PRICEREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** reduced cost pricing method of variable pricer for feasible LPs +# * +# * Searches for variables that can contribute to improve the current LP's solution value. +# * In standard branch-and-price, these are variables with negative dual feasibility, that is negative +# * reduced costs for non-negative variables, positive reduced costs for non-positive variables, +# * and non-zero reduced costs for variables that can be negative and positive. +# * +# * The method is called in the LP solving loop after an LP was proven to be feasible. +# * +# * Whenever the pricer finds a variable with negative dual feasibility, it should call SCIPcreateVar() +# * and SCIPaddPricedVar() to add the variable to the problem. Furthermore, it should call the appropriate +# * methods of the constraint handlers to add the necessary variable entries to the constraints. +# * +# * In the usual case that the pricer either adds a new variable or ensures that there are no further variables with +# * negative dual feasibility, the result pointer should be set to SCIP_SUCCESS. Only if the pricer aborts pricing +# * without creating a new variable, but there might exist additional variables with negative dual feasibility, the +# * result pointer should be set to SCIP_DIDNOTRUN. In this case, which sometimes is referred to as "early branching", +# * the lp solution will not be used as a lower bound. The pricer can, however, store a valid lower bound in the +# * lowerbound pointer. If you use your own branching rule (e.g., to branch on constraints), make sure that it is able +# * to branch on pseudo solutions. Otherwise, SCIP will use its default branching rules (which all branch on +# * variables). This could disturb the pricing problem or branching might not even be possible, e.g., if all yet created +# * variables have already been fixed. +# * +# * input: +# * - scip : SCIP main data structure +# * - pricer : the variable pricer itself +# * - lowerbound : pointer to store a lower bound found by the pricer +# * - stopearly : should pricing be stopped, although new variables were added? (doing early branching) +# * - result : pointer to store the result of the pricer call +# * +# * possible return values for *result: +# * - SCIP_SUCCESS : at least one improving variable was found, or it is ensured that no such variable exists +# * - SCIP_DIDNOTRUN : the pricing process was aborted by the pricer, there is no guarantee that the current LP solution is +# * optimal +# * +# */ +# Skipping MacroDefinition: SCIP_DECL_PRICERREDCOST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_Real * lowerbound , SCIP_Bool * stopearly , SCIP_RESULT * result ) /** Farkas pricing method of variable pricer for infeasible LPs +# * +# * Searches for variables that can contribute to the feasibility of the current LP. +# * In standard branch-and-price, these are variables with positive Farkas values: +# * +# * The LP was proven infeasible, so we have an infeasibility proof by the dual Farkas multipliers y. +# * With the values of y, an implicit inequality y^T A x >= y^T b is associated, with b given +# * by the sides of the LP rows and the sign of y: +# * - if y_i is positive, b_i is the left hand side of the row, +# * - if y_i is negative, b_i is the right hand side of the row. +# * +# * y is chosen in a way, such that the valid inequality y^T A x >= y^T b is violated by all x, +# * especially by the (for this inequality least infeasible solution) x' defined by +# * x'_i := ub_i, if y^T A_i >= 0 +# * x'_i := lb_i, if y^T A_i < 0. +# * Pricing in this case means to add variables i with positive Farkas value, i.e. y^T A_i x'_i > 0. +# * +# * The method is called in the LP solving loop after an LP was proven to be infeasible. +# * +# * Whenever the pricer finds a variable with positive Farkas value, it should call SCIPcreateVar() +# * and SCIPaddPricedVar() to add the variable to the problem. Furthermore, it should call the appropriate +# * methods of the constraint handlers to add the necessary variable entries to the constraints. +# * +# * input: +# * - scip : SCIP main data structure +# * - pricer : the variable pricer itself +# * - result : pointer to store the result of the pricer call +# * +# * possible return values for *result: +# * - SCIP_SUCCESS : at least one variable was found, which can contribute to the feasibility of the current LP, +# * or it is ensured that no such variable exists +# * - SCIP_DIDNOTRUN : the pricing process was aborted by the pricer, there is no guarantee that the current LP is indeed infeasible +# */ +# Skipping MacroDefinition: SCIP_DECL_PRICERFARKAS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_RESULT * result ) # + +struct SCIP_Pricer +end + +const SCIP_PRICER = Cvoid + +struct SCIP_PricerData +end + +const SCIP_PRICERDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_PROPCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** destructor of propagator to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** initialization method of propagator (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** deinitialization method of propagator (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** presolving initialization method of propagator (called when presolving is about to begin) +# * +# * This method is called when the presolving process is about to begin, even if presolving is turned off. The +# * propagator may use this call to initialize its presolving data, before the presolving process begins. +# * +# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the +# * presolving deinitialization call (SCIP_DECL_PROPEXITPRE()). +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** presolving deinitialization method of propagator (called after presolving has been finished) +# * +# * This method is called after the presolving has been finished, even if presolving is turned off. +# * The propagator may use this call e.g. to clean up its presolving data. +# * +# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the +# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, +# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** solving process initialization method of propagator (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The propagator may use this call to initialize its branch and bound specific data. +# * +# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the +# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, +# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** solving process deinitialization method of propagator (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The propagator should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# * - restart : was this exit solve call triggered by a restart? +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_Bool restart ) /** presolving method of propagator +# * +# * The presolver should go through the variables and constraints and tighten the domains or +# * constraints. Each tightening should increase the given total numbers of changes. +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# * - nrounds : number of presolving rounds already done +# * - presoltiming : current presolving timing +# * - nnewfixedvars : number of variables fixed since the last call to the presolving method +# * - nnewaggrvars : number of variables aggregated since the last call to the presolving method +# * - nnewchgvartypes : number of variable type changes since the last call to the presolving method +# * - nnewchgbds : number of variable bounds tightened since the last call to the presolving method +# * - nnewholes : number of domain holes added since the last call to the presolving method +# * - nnewdelconss : number of deleted constraints since the last call to the presolving method +# * - nnewaddconss : number of added constraints since the last call to the presolving method +# * - nnewupgdconss : number of upgraded constraints since the last call to the presolving method +# * - nnewchgcoefs : number of changed coefficients since the last call to the presolving method +# * - nnewchgsides : number of changed left or right hand sides since the last call to the presolving method +# * +# * @note the counters state the changes since the last call including the changes of this presolving method during its +# * last call +# * +# * @note if the propagator uses dual information for presolving it is nesassary to check via calling SCIPallowDualReds +# * if dual reductions are allowed. +# * +# * input/output: +# * - nfixedvars : pointer to total number of variables fixed of all presolvers +# * - naggrvars : pointer to total number of variables aggregated of all presolvers +# * - nchgvartypes : pointer to total number of variable type changes of all presolvers +# * - nchgbds : pointer to total number of variable bounds tightened of all presolvers +# * - naddholes : pointer to total number of domain holes added of all presolvers +# * - ndelconss : pointer to total number of deleted constraints of all presolvers +# * - naddconss : pointer to total number of added constraints of all presolvers +# * - nupgdconss : pointer to total number of upgraded constraints of all presolvers +# * - nchgcoefs : pointer to total number of changed coefficients of all presolvers +# * - nchgsides : pointer to total number of changed left/right hand sides of all presolvers +# * +# * output: +# * - result : pointer to store the result of the presolving call +# * +# * possible return values for *result: +# * - SCIP_UNBOUNDED : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded +# * - SCIP_CUTOFF : at least one constraint is infeasible in the variable's bounds -> problem is infeasible +# * - SCIP_SUCCESS : the presolving method found a reduction +# * - SCIP_DIDNOTFIND : the presolving method searched, but did not find a presolving change +# * - SCIP_DIDNOTRUN : the presolving method was skipped +# * - SCIP_DELAYED : the presolving method was skipped, but should be called again +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPPRESOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) /** execution method of propagator +# * +# * Searches for domain propagations. The method is called in the node processing loop. +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# * - proptiming : current point in the node solving loop +# * - result : pointer to store the result of the propagation call +# * +# * possible return values for *result: +# * - SCIP_CUTOFF : the current node is infeasible for the current domains +# * - SCIP_REDUCEDDOM : at least one domain reduction was found +# * - SCIP_DIDNOTFIND : the propagator searched, but did not find a domain reduction +# * - SCIP_DIDNOTRUN : the propagator was skipped +# * - SCIP_DELAYED : the propagator was skipped, but should be called again +# * - SCIP_DELAYNODE : the current node should be postponed (return value only valid for BEFORELP propagation) +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_PROPTIMING proptiming , SCIP_RESULT * result ) /** propagation conflict resolving method of propagator +# * +# * This method is called during conflict analysis. If the propagator wants to support conflict analysis, +# * it should call SCIPinferVarLbProp() or SCIPinferVarUbProp() in domain propagation instead of SCIPchgVarLb() or +# * SCIPchgVarUb() in order to deduce bound changes on variables. +# * In the SCIPinferVarLbProp() and SCIPinferVarUbProp() calls, the propagator provides a pointer to itself +# * and an integer value "inferinfo" that can be arbitrarily chosen. +# * The propagation conflict resolving method can then be implemented, to provide a "reasons" for the bound +# * changes, i.e. the bounds of variables at the time of the propagation, that forced the propagator to set the +# * conflict variable's bound to its current value. It can use the "inferinfo" tag to identify its own propagation +# * rule and thus identify the "reason" bounds. The bounds that form the reason of the assignment must then be provided +# * by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), +# * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and/or SCIPaddConflictBinvar() in the propagation conflict +# * resolving method. +# * +# * See the description of the propagation conflict resolving method of constraint handlers for further details. +# * +# * @note if the propagtor uses dual information it is nesassary to check via calling SCIPallowDualReds and +# * SCIPallowObjProp if dual reductions and propgation with the current cutoff bound, resp., are allowed. +# * +# * input: +# * - scip : SCIP main data structure +# * - prop : the propagator itself +# * - infervar : the conflict variable whose bound change has to be resolved +# * - inferinfo : the user information passed to the corresponding SCIPinferVarLbProp() or SCIPinferVarUbProp() call +# * - boundtype : the type of the changed bound (lower or upper bound) +# * - bdchgidx : the index of the bound change, representing the point of time where the change took place +# * - relaxedbd : the relaxed bound which is sufficient to be explained +# * +# * output: +# * - result : pointer to store the result of the propagation conflict resolving call +# * +# * possible return values for *result: +# * - SCIP_SUCCESS : the conflicting bound change has been successfully resolved by adding all reason bounds +# * - SCIP_DIDNOTFIND : the conflicting bound change could not be resolved and has to be put into the conflict set +# * +# * @note it is sufficient to explain/resolve the relaxed bound +# */ +# Skipping MacroDefinition: SCIP_DECL_PROPRESPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_VAR * infervar , int inferinfo , SCIP_BOUNDTYPE boundtype , SCIP_BDCHGIDX * bdchgidx , SCIP_Real relaxedbd , SCIP_RESULT * result ) # + +struct SCIP_Prop +end + +const SCIP_PROP = Cvoid + +struct SCIP_PropData +end + +const SCIP_PROPDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_READERCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader ) /** destructor of reader to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - reader : the reader itself +# */ +# Skipping MacroDefinition: SCIP_DECL_READERFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader ) /** problem reading method of reader +# * +# * input: +# * - scip : SCIP main data structure +# * - reader : the reader itself +# * - filename : full path and name of file to read, or NULL if stdin should be used +# * - result : pointer to store the result of the file reading call +# * +# * possible return values for *result: +# * - SCIP_SUCCESS : the reader read the file correctly and created an appropriate problem +# * - SCIP_DIDNOTRUN : the reader is not responsible for given input file +# * +# * If the reader detected an error in the input file, it should return with RETCODE SCIP_READERROR or SCIP_NOFILE. +# */ +# Skipping MacroDefinition: SCIP_DECL_READERREAD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader , const char * filename , SCIP_RESULT * result ) /** problem writing method of reader; NOTE: if the parameter "genericnames" is TRUE, then +# * SCIP already set all variable and constraint names to generic names; therefore, this +# * method should always use SCIPvarGetName() and SCIPconsGetName(); +# * +# * input: +# * - scip : SCIP main data structure +# * - reader : the reader itself +# * - file : output file, or NULL if standard output should be used +# * - name : problem name +# * - probdata : user problem data set by the reader +# * - transformed : TRUE iff problem is the transformed problem +# * - objsense : objective sense +# * - objscale : scalar applied to objective function; external objective value is +# extobj = objsense * objscale * (intobj + objoffset) +# * - objoffset : objective offset from bound shifting and fixing +# * - vars : array with active variables ordered binary, integer, implicit, continuous +# * - nvars : number of active variables in the problem +# * - nbinvars : number of binary variables +# * - nintvars : number of general integer variables +# * - nimplvars : number of implicit integer variables +# * - ncontvars; : number of continuous variables +# * - fixedvars : array with fixed and aggregated variables +# * - nfixedvars : number of fixed and aggregated variables in the problem +# * - startnvars : number of variables existing when problem solving started +# * - conss : array with constraints of the problem +# * - nconss : number of constraints in the problem +# * - maxnconss : maximum number of constraints existing at the same time +# * - startnconss : number of constraints existing when problem solving started +# * - genericnames : using generic variable and constraint names? +# * - result : pointer to store the result of the file reading call +# * +# * possible return values for *result: +# * - SCIP_SUCCESS : the reader wrote the file correctly +# * - SCIP_DIDNOTRUN : the reader is not responsible for given input file +# * +# * If the reader detected an error while writing the output file, it should return with RETCODE SCIP_WRITEERROR +# */ +# Skipping MacroDefinition: SCIP_DECL_READERWRITE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader , FILE * file , const char * name , SCIP_PROBDATA * probdata , SCIP_Bool transformed , SCIP_OBJSENSE objsense , SCIP_Real objscale , SCIP_Real objoffset , SCIP_VAR * * vars , int nvars , int nbinvars , int nintvars , int nimplvars , int ncontvars , SCIP_VAR * * fixedvars , int nfixedvars , int startnvars , SCIP_CONS * * conss , int nconss , int maxnconss , int startnconss , SCIP_Bool genericnames , SCIP_RESULT * result ) # + +struct SCIP_Reader +end + +const SCIP_READER = Cvoid + +struct SCIP_ReaderData +end + +const SCIP_READERDATA = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_RELAXCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** destructor of relaxator to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - relax : the relaxator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_RELAXFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** initialization method of relaxator (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - relax : the relaxator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_RELAXINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** deinitialization method of relaxator (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - relax : the relaxator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_RELAXEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** solving process initialization method of relaxator (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The relaxator may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - relax : the relaxator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_RELAXINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** solving process deinitialization method of relaxator (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The relaxator should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - relax : the relaxator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_RELAXEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** execution method of relaxator +# * +# * The method is called in the node processing loop. It solves the current subproblem's relaxation. +# * Like the LP relaxation, the relaxator should only operate on COLUMN variables. +# * +# * input: +# * - scip : SCIP main data structure +# * - relax : the relaxator itself +# * - lowerbound : pointer to store a lowerbound for the current node +# * - result : pointer to store the result of the relaxation call +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_CONSADDED : an additional constraint was generated, and the relaxator should not be called again on the +# * same relaxation +# * - SCIP_REDUCEDDOM : a variable's domain was reduced, and the relaxator should not be called again on the same +# * relaxation +# * - SCIP_SEPARATED : a cutting plane was generated, and the relaxator should not be called again on the same relaxation +# * - SCIP_SUCCESS : the relaxator solved the relaxation and should not be called again on the same relaxation +# * - SCIP_SUSPENDED : the relaxator interrupted its solving process to wait for additional input (e.g. cutting +# * planes); however, it is able to continue the solving in order to improve the dual bound +# * - SCIP_DIDNOTRUN : the relaxator was skipped +# */ +# Skipping MacroDefinition: SCIP_DECL_RELAXEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax , SCIP_Real * lowerbound , SCIP_RESULT * result ) # + +struct SCIP_Relax +end + +const SCIP_RELAX = Cvoid + +struct SCIP_Relaxation +end + +const SCIP_RELAXATION = Cvoid + +struct SCIP_RelaxData +end + +const SCIP_RELAXDATA = Cvoid + +struct SCIP_Reopt +end + +const SCIP_REOPT = Cvoid + +struct SCIP_SolTree +end + +const SCIP_SOLTREE = Cvoid + +struct SCIP_SolNode +end + +const SCIP_SOLNODE = Cvoid + +struct SCIP_ReoptTree +end + +const SCIP_REOPTTREE = Cvoid + +struct SCIP_ReoptNode +end + +const SCIP_REOPTNODE = Cvoid +const SCIP_REPRESENTATIVE = Cvoid + +struct SCIP_ReoptConsData +end + +const SCIP_REOPTCONSDATA = Cvoid + +# begin enum SCIP_ReoptType +const SCIP_ReoptType = UInt32 +const SCIP_REOPTTYPE_NONE = 0 |> UInt32 +const SCIP_REOPTTYPE_TRANSIT = 1 |> UInt32 +const SCIP_REOPTTYPE_INFSUBTREE = 2 |> UInt32 +const SCIP_REOPTTYPE_STRBRANCHED = 3 |> UInt32 +const SCIP_REOPTTYPE_LOGICORNODE = 4 |> UInt32 +const SCIP_REOPTTYPE_LEAF = 5 |> UInt32 +const SCIP_REOPTTYPE_PRUNED = 6 |> UInt32 +const SCIP_REOPTTYPE_FEASIBLE = 7 |> UInt32 +# end enum SCIP_ReoptType + +const SCIP_REOPTTYPE = SCIP_ReoptType + +# begin enum Reopt_ConsType +const Reopt_ConsType = UInt32 +const REOPT_CONSTYPE_INFSUBTREE = 0 |> UInt32 +const REOPT_CONSTYPE_DUALREDS = 1 |> UInt32 +const REOPT_CONSTYPE_CUT = 2 |> UInt32 +const REOPT_CONSTYPE_UNKNOWN = 3 |> UInt32 +# end enum Reopt_ConsType + +const REOPT_CONSTYPE = Reopt_ConsType + +# Skipping MacroDefinition: SCIP_DECL_SEPACOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** destructor of separator to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - sepa : the separator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_SEPAFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** initialization method of separator (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - sepa : the separator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_SEPAINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** deinitialization method of separator (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - sepa : the separator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_SEPAEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** solving process initialization method of separator (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The separator may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - sepa : the separator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_SEPAINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** solving process deinitialization method of separator (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The separator should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - sepa : the separator itself +# */ +# Skipping MacroDefinition: SCIP_DECL_SEPAEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** LP solution separation method of separator +# * +# * Searches for cutting planes that separate the current LP solution. The method is called in the LP solving loop, +# * which means that a valid LP solution exists. +# * +# * input: +# * - scip : SCIP main data structure +# * - sepa : the separator itself +# * - result : pointer to store the result of the separation call +# * - allowlocal : should the separator allow local cuts? +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_CONSADDED : an additional constraint was generated +# * - SCIP_REDUCEDDOM : a variable's domain was reduced +# * - SCIP_SEPARATED : a cutting plane was generated +# * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start +# * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints +# * - SCIP_DIDNOTRUN : the separator was skipped +# * - SCIP_DELAYED : the separator was skipped, but should be called again +# */ +# Skipping MacroDefinition: SCIP_DECL_SEPAEXECLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa , SCIP_RESULT * result , SCIP_Bool allowlocal ) /** arbitrary primal solution separation method of separator +# * +# * Searches for cutting planes that separate the given primal solution. The method is called outside the LP solution +# * loop (e.g., by a relaxator or a primal heuristic), which means that there is no valid LP solution. +# * +# * input: +# * - scip : SCIP main data structure +# * - sepa : the separator itself +# * - sol : primal solution that should be separated +# * - result : pointer to store the result of the separation call +# * - allowlocal : should the separator allow local cuts? +# * +# * possible return values for *result (if more than one applies, the first in the list should be used): +# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off +# * - SCIP_CONSADDED : an additional constraint was generated +# * - SCIP_REDUCEDDOM : a variable's domain was reduced +# * - SCIP_SEPARATED : a cutting plane was generated +# * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start +# * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints +# * - SCIP_DIDNOTRUN : the separator was skipped +# * - SCIP_DELAYED : the separator was skipped, but should be called again +# */ +# Skipping MacroDefinition: SCIP_DECL_SEPAEXECSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa , SCIP_SOL * sol , SCIP_RESULT * result , SCIP_Bool allowlocal ) # + +struct SCIP_Sepa +end + +const SCIP_SEPA = Cvoid + +struct SCIP_SepaData +end + +const SCIP_SEPADATA = Cvoid + +# begin enum SCIP_Stage +const SCIP_Stage = UInt32 +const SCIP_STAGE_INIT = 0 |> UInt32 +const SCIP_STAGE_PROBLEM = 1 |> UInt32 +const SCIP_STAGE_TRANSFORMING = 2 |> UInt32 +const SCIP_STAGE_TRANSFORMED = 3 |> UInt32 +const SCIP_STAGE_INITPRESOLVE = 4 |> UInt32 +const SCIP_STAGE_PRESOLVING = 5 |> UInt32 +const SCIP_STAGE_EXITPRESOLVE = 6 |> UInt32 +const SCIP_STAGE_PRESOLVED = 7 |> UInt32 +const SCIP_STAGE_INITSOLVE = 8 |> UInt32 +const SCIP_STAGE_SOLVING = 9 |> UInt32 +const SCIP_STAGE_SOLVED = 10 |> UInt32 +const SCIP_STAGE_EXITSOLVE = 11 |> UInt32 +const SCIP_STAGE_FREETRANS = 12 |> UInt32 +const SCIP_STAGE_FREE = 13 |> UInt32 +# end enum SCIP_Stage + +const SCIP_STAGE = SCIP_Stage + +# begin enum SCIP_Setting +const SCIP_Setting = UInt32 +const SCIP_UNDEFINED = 0 |> UInt32 +const SCIP_DISABLED = 1 |> UInt32 +const SCIP_AUTO = 2 |> UInt32 +const SCIP_ENABLED = 3 |> UInt32 +# end enum SCIP_Setting + +const SCIP_SETTING = SCIP_Setting + +struct SCIP_Set +end + +const SCIP_SET = Cvoid + +# begin enum SCIP_SolOrigin +const SCIP_SolOrigin = UInt32 +const SCIP_SOLORIGIN_ORIGINAL = 0 |> UInt32 +const SCIP_SOLORIGIN_ZERO = 1 |> UInt32 +const SCIP_SOLORIGIN_LPSOL = 2 |> UInt32 +const SCIP_SOLORIGIN_NLPSOL = 3 |> UInt32 +const SCIP_SOLORIGIN_RELAXSOL = 4 |> UInt32 +const SCIP_SOLORIGIN_PSEUDOSOL = 5 |> UInt32 +const SCIP_SOLORIGIN_PARTIAL = 6 |> UInt32 +const SCIP_SOLORIGIN_UNKNOWN = 7 |> UInt32 +# end enum SCIP_SolOrigin + +const SCIP_SOLORIGIN = SCIP_SolOrigin + +struct SCIP_Sol +end + +const SCIP_SOL = Cvoid + +struct SCIP_Viol +end + +const SCIP_VIOL = Cvoid + +# begin enum SCIP_Status +const SCIP_Status = UInt32 +const SCIP_STATUS_UNKNOWN = 0 |> UInt32 +const SCIP_STATUS_USERINTERRUPT = 1 |> UInt32 +const SCIP_STATUS_NODELIMIT = 2 |> UInt32 +const SCIP_STATUS_TOTALNODELIMIT = 3 |> UInt32 +const SCIP_STATUS_STALLNODELIMIT = 4 |> UInt32 +const SCIP_STATUS_TIMELIMIT = 5 |> UInt32 +const SCIP_STATUS_MEMLIMIT = 6 |> UInt32 +const SCIP_STATUS_GAPLIMIT = 7 |> UInt32 +const SCIP_STATUS_SOLLIMIT = 8 |> UInt32 +const SCIP_STATUS_BESTSOLLIMIT = 9 |> UInt32 +const SCIP_STATUS_RESTARTLIMIT = 10 |> UInt32 +const SCIP_STATUS_OPTIMAL = 11 |> UInt32 +const SCIP_STATUS_INFEASIBLE = 12 |> UInt32 +const SCIP_STATUS_UNBOUNDED = 13 |> UInt32 +const SCIP_STATUS_INFORUNBD = 14 |> UInt32 +const SCIP_STATUS_TERMINATE = 15 |> UInt32 +# end enum SCIP_Status + +const SCIP_STATUS = SCIP_Status + +struct SCIP_Stat +end + +const SCIP_STAT = Cvoid + +# begin enum SCIP_Parallelmode +const SCIP_Parallelmode = UInt32 +const SCIP_PARA_OPPORTUNISTIC = 0 |> UInt32 +const SCIP_PARA_DETERMINISTIC = 1 |> UInt32 +# end enum SCIP_Parallelmode + +const SCIP_PARALLELMODE = SCIP_Parallelmode + +struct SCIP_SyncStore +end + +const SCIP_SYNCSTORE = Cvoid + +struct SCIP_SyncData +end + +const SCIP_SYNCDATA = Cvoid + +struct SCIP_BoundStore +end + +const SCIP_BOUNDSTORE = Cvoid + +# Skipping MacroDefinition: SCIP_DECL_TABLECOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** destructor of statistics table to free user data (called when SCIP is exiting) +# * +# * input: +# * - scip : SCIP main data structure +# * - table : the statistics table itself +# */ +# Skipping MacroDefinition: SCIP_DECL_TABLEFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** initialization method of statistics table (called after problem was transformed) +# * +# * input: +# * - scip : SCIP main data structure +# * - table : the statistics table itself +# */ +# Skipping MacroDefinition: SCIP_DECL_TABLEINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** deinitialization method of statistics table (called before transformed problem is freed) +# * +# * input: +# * - scip : SCIP main data structure +# * - table : the statistics table itself +# */ +# Skipping MacroDefinition: SCIP_DECL_TABLEEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** solving process initialization method of statistics table (called when branch and bound process is about to begin) +# * +# * This method is called when the presolving was finished and the branch and bound process is about to begin. +# * The statistics table may use this call to initialize its branch and bound specific data. +# * +# * input: +# * - scip : SCIP main data structure +# * - table : the statistics table itself +# */ +# Skipping MacroDefinition: SCIP_DECL_TABLEINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** solving process deinitialization method of statistics table (called before branch and bound process data is freed) +# * +# * This method is called before the branch and bound process is freed. +# * The statistics table should use this call to clean up its branch and bound data. +# * +# * input: +# * - scip : SCIP main data structure +# * - table : the display column itself +# */ +# Skipping MacroDefinition: SCIP_DECL_TABLEEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** output method of statistics table to output file stream 'file' +# * +# * input: +# * - scip : SCIP main data structure +# * - table : the statistics table itself +# * - file : file stream for output +# */ +# Skipping MacroDefinition: SCIP_DECL_TABLEOUTPUT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table , FILE * file ) # + +struct SCIP_Table +end + +const SCIP_TABLE = Cvoid + +struct SCIP_TableData +end + +const SCIP_TABLEDATA = Cvoid + +struct SCIP_Concurrent +end + +const SCIP_CONCURRENT = Cvoid + +struct SCIP_ConflictStore +end + +const SCIP_CONFLICTSTORE = Cvoid + +struct SCIP_AggrRow +end + +const SCIP_AGGRROW = Cvoid + +struct SCIP_Interrupt +end + +const SCIP_INTERRUPT = Cvoid + +struct SCIP_Matrix +end + +const SCIP_MATRIX = Cvoid + +struct SCIP_Mem +end + +const SCIP_MEM = Cvoid + +struct SCIP_Pricestore +end + +const SCIP_PRICESTORE = Cvoid + +struct SCIP_Primal +end + +const SCIP_PRIMAL = Cvoid + +# begin enum SCIP_Efficiacychoice +const SCIP_Efficiacychoice = UInt32 +const SCIP_EFFICIACYCHOICE_LP = 0 |> UInt32 +const SCIP_EFFICIACYCHOICE_RELAX = 1 |> UInt32 +const SCIP_EFFICIACYCHOICE_NLP = 2 |> UInt32 +# end enum SCIP_Efficiacychoice + +const SCIP_EFFICIACYCHOICE = SCIP_Efficiacychoice + +struct SCIP_SepaStore +end + +const SCIP_SEPASTORE = Cvoid + +# begin enum SCIP_VBCColor +const SCIP_VBCColor = Cint +const SCIP_VBCCOLOR_UNSOLVED = 3 |> Int32 +const SCIP_VBCCOLOR_SOLVED = 2 |> Int32 +const SCIP_VBCCOLOR_CUTOFF = 4 |> Int32 +const SCIP_VBCCOLOR_CONFLICT = 15 |> Int32 +const SCIP_VBCCOLOR_MARKREPROP = 11 |> Int32 +const SCIP_VBCCOLOR_REPROP = 12 |> Int32 +const SCIP_VBCCOLOR_SOLUTION = 14 |> Int32 +const SCIP_VBCCOLOR_NONE = -1 |> Int32 +# end enum SCIP_VBCColor + +const SCIP_VBCCOLOR = SCIP_VBCColor + +struct SCIP_Visual +end + +const SCIP_VISUAL = Cvoid + # Skipping MacroDefinition: SCIPallocMemory ( scip , ptr ) ( ( BMSallocMemory ( ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # # Skipping MacroDefinition: SCIPallocMemoryArray ( scip , ptr , num ) ( ( BMSallocMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # # Skipping MacroDefinition: SCIPallocClearMemoryArray ( scip , ptr , num ) ( ( BMSallocClearMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # From 479aae1dd0690bc91fed38a303d6e6890a862f76 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 14 Dec 2018 23:55:10 +0100 Subject: [PATCH 06/82] don't add pub_*.h headers (for now) --- gen/generate_wrapper.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index a535bea9..2e8d9ce9 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -22,6 +22,7 @@ top_types = [ headers = vcat( filter(h -> h != "type_var.h", top_types), # problem: `union SCIP_DomChg` filter(h -> startswith(h, "type_") && !in(h, top_types), all_headers), + # filter(h -> startswith(h, "pub_"), all_headers), filter(h -> startswith(h, "scip_"), all_headers), ) clang_includes = [ From d221a070d9d7d71dccfa22515b611922ced1ec96 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 00:58:54 +0100 Subject: [PATCH 07/82] also wrap type_var.h - requires updated Clang.jl with #214 fixed. --- gen/generate_wrapper.jl | 2 +- src/wrapper/commons.jl | 205 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 206 insertions(+), 1 deletion(-) diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index 2e8d9ce9..8d59ce40 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -20,7 +20,7 @@ top_types = [ ] headers = vcat( - filter(h -> h != "type_var.h", top_types), # problem: `union SCIP_DomChg` + top_types, filter(h -> startswith(h, "type_") && !in(h, top_types), all_headers), # filter(h -> startswith(h, "pub_"), all_headers), filter(h -> startswith(h, "scip_"), all_headers), diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index cb680237..1badb1df 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -600,6 +600,211 @@ struct SCIP_Nlp end const SCIP_NLP = Cvoid +const NLOCKTYPES = 2 + +# Skipping MacroDefinition: SCIP_DECL_VARDELORIG ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * var , SCIP_VARDATA * * vardata ) /** creates transformed variable for original user variable +# * +# * Because the original variable and the user data of the original variable should not be +# * modified during the solving process, a transformed variable is created as a copy of +# * the original variable. If the user variable data is never modified during the solving +# * process anyways, it is enough to simple copy the user data's pointer. This is the +# * default implementation, which is used when a NULL is given as VARTRANS method. +# * If the user data may be modified during the solving process (e.g. during preprocessing), +# * the VARTRANS method must be given and has to copy the user variable data to a different +# * memory location. +# * +# * input: +# * - scip : SCIP main data structure +# * - sourcevar : original variable +# * - sourcedata : source variable data to transform +# * - targetvar : transformed variable +# * - targetdata : pointer to store created transformed variable data +# */ +# Skipping MacroDefinition: SCIP_DECL_VARTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * sourcevar , SCIP_VARDATA * sourcedata , SCIP_VAR * targetvar , SCIP_VARDATA * * targetdata ) /** frees user data of transformed variable (called when the transformed variable is freed) +# * +# * This method has to be implemented, if the VARTRANS method is not a simple pointer +# * copy operation like in the default VARTRANS implementation. It should free the +# * user data of the transformed variable, that was created in the VARTRANS method. +# * +# * input: +# * - scip : SCIP main data structure +# * - var : transformed variable the data to free is belonging to +# * - vardata : pointer to the user variable data to free +# */ +# Skipping MacroDefinition: SCIP_DECL_VARDELTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * var , SCIP_VARDATA * * vardata ) /** copies variable data of source SCIP variable for the target SCIP variable +# * +# * This method should copy the variable data of the source SCIP and create a target variable data for target +# * variable. This callback is optimal. If the copying process was successful the target variable gets this variable +# * data assigned. In case the result pointer is set to SCIP_DIDNOTRUN the target variable will have no variable data at +# * all. +# * +# * The variable map and the constraint map can be used via the function SCIPgetVarCopy() and SCIPgetConsCopy(), +# * respectively, to get for certain variables and constraints of the source SCIP the counter parts in the target +# * SCIP. You should be very carefully in using these two methods since they could lead to infinity loop. +# * +# * input: +# * - scip : target SCIP data structure +# * - sourcescip : source SCIP main data structure +# * - sourcevar : variable of the source SCIP +# * - sourcedata : variable data of the source variable which should get copied +# * - varmap, : a hashmap which stores the mapping of source variables to corresponding target variables +# * - consmap, : a hashmap which stores the mapping of source constraints to corresponding target constraints +# * - targetvar : variable of the (target) SCIP (targetvar is the copy of sourcevar) +# * - targetdata : pointer to store created copy of the variable data for the (target) SCIP +# * +# * output: +# * - result : pointer to store the result of the call +# * +# * possible return values for *result: +# * - SCIP_DIDNOTRUN : the copying process was not performed +# * - SCIP_SUCCESS : the copying process was successfully performed +# */ +# Skipping MacroDefinition: SCIP_DECL_VARCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP * sourcescip , SCIP_VAR * sourcevar , SCIP_VARDATA * sourcedata , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_VAR * targetvar , SCIP_VARDATA * * targetdata , SCIP_RESULT * result ) # + +# begin enum SCIP_Varstatus +const SCIP_Varstatus = UInt32 +const SCIP_VARSTATUS_ORIGINAL = 0 |> UInt32 +const SCIP_VARSTATUS_LOOSE = 1 |> UInt32 +const SCIP_VARSTATUS_COLUMN = 2 |> UInt32 +const SCIP_VARSTATUS_FIXED = 3 |> UInt32 +const SCIP_VARSTATUS_AGGREGATED = 4 |> UInt32 +const SCIP_VARSTATUS_MULTAGGR = 5 |> UInt32 +const SCIP_VARSTATUS_NEGATED = 6 |> UInt32 +# end enum SCIP_Varstatus + +const SCIP_VARSTATUS = SCIP_Varstatus + +# begin enum SCIP_Vartype +const SCIP_Vartype = UInt32 +const SCIP_VARTYPE_BINARY = 0 |> UInt32 +const SCIP_VARTYPE_INTEGER = 1 |> UInt32 +const SCIP_VARTYPE_IMPLINT = 2 |> UInt32 +const SCIP_VARTYPE_CONTINUOUS = 3 |> UInt32 +# end enum SCIP_Vartype + +const SCIP_VARTYPE = SCIP_Vartype + +# begin enum SCIP_DomchgType +const SCIP_DomchgType = UInt32 +const SCIP_DOMCHGTYPE_DYNAMIC = 0 |> UInt32 +const SCIP_DOMCHGTYPE_BOTH = 1 |> UInt32 +const SCIP_DOMCHGTYPE_BOUND = 2 |> UInt32 +# end enum SCIP_DomchgType + +const SCIP_DOMCHGTYPE = SCIP_DomchgType + +# begin enum SCIP_BoundchgType +const SCIP_BoundchgType = UInt32 +const SCIP_BOUNDCHGTYPE_BRANCHING = 0 |> UInt32 +const SCIP_BOUNDCHGTYPE_CONSINFER = 1 |> UInt32 +const SCIP_BOUNDCHGTYPE_PROPINFER = 2 |> UInt32 +# end enum SCIP_BoundchgType + +const SCIP_BOUNDCHGTYPE = SCIP_BoundchgType + +# begin enum SCIP_LockType +const SCIP_LockType = UInt32 +const SCIP_LOCKTYPE_MODEL = 0 |> UInt32 +const SCIP_LOCKTYPE_CONFLICT = 1 |> UInt32 +# end enum SCIP_LockType + +const SCIP_LOCKTYPE = SCIP_LockType + +struct SCIP_DomChgBound +end + +const SCIP_DOMCHGBOUND = Cvoid + +struct SCIP_DomChgBoth +end + +const SCIP_DOMCHGBOTH = Cvoid + +struct SCIP_DomChgDyn +end + +const SCIP_DOMCHGDYN = Cvoid + +struct SCIP_DomChg + _SCIP_DomChg::Cvoid +end + +const SCIP_DOMCHG = Cvoid + +struct SCIP_BoundChg +end + +const SCIP_BOUNDCHG = Cvoid + +struct SCIP_BdChgIdx +end + +const SCIP_BDCHGIDX = Cvoid + +struct SCIP_BdChgInfo +end + +const SCIP_BDCHGINFO = Cvoid + +struct SCIP_BranchingData +end + +const SCIP_BRANCHINGDATA = Cvoid + +struct SCIP_InferenceData +end + +const SCIP_INFERENCEDATA = Cvoid + +struct SCIP_HoleChg +end + +const SCIP_HOLECHG = Cvoid + +struct SCIP_Hole +end + +const SCIP_HOLE = Cvoid + +struct SCIP_Holelist +end + +const SCIP_HOLELIST = Cvoid + +struct SCIP_Dom +end + +const SCIP_DOM = Cvoid + +struct SCIP_Original +end + +const SCIP_ORIGINAL = Cvoid + +struct SCIP_Aggregate +end + +const SCIP_AGGREGATE = Cvoid + +struct SCIP_Multaggr +end + +const SCIP_MULTAGGR = Cvoid + +struct SCIP_Negate +end + +const SCIP_NEGATE = Cvoid + +struct SCIP_Var +end + +const SCIP_VAR = Cvoid + +struct SCIP_VarData +end + +const SCIP_VARDATA = Cvoid # Skipping MacroDefinition: SCIP_DECL_PROBDELORIG ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * * probdata ) /** creates user data of transformed problem by transforming the original user problem data # * (called after problem was transformed) From d84a7720617022568c6d895e556c2bb773a3b519 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 20:38:11 +0100 Subject: [PATCH 08/82] adapt generate_wrapper.jl to `restruct` branch of Clang.jl - see PR https://github.com/ihnorton/Clang.jl/pull/210 - and discussion at https://github.com/ihnorton/Clang.jl/issues/214 --- gen/generate_wrapper.jl | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index 8d59ce40..f43144a0 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -1,8 +1,8 @@ using Clang -header_path = "/usr/include/scip" -all_headers = readdir(header_path) - +HEADER_BASE = "/usr/include" # using system-wide installation of SCIP +HEADER_DIR = "scip" +all_headers = readdir(joinpath(HEADER_BASE, HEADER_DIR)) top_types = [ "type_retcode.h", "type_result.h", @@ -18,27 +18,21 @@ top_types = [ "type_tree.h", "type_scip.h", ] - headers = vcat( top_types, filter(h -> startswith(h, "type_") && !in(h, top_types), all_headers), # filter(h -> startswith(h, "pub_"), all_headers), filter(h -> startswith(h, "scip_"), all_headers), ) -clang_includes = [ - "/usr/lib/llvm-6.0/lib/clang/6.0.0/include", -] -context = Clang.wrap_c.init( - # header files we want wrapped - headers=[joinpath(header_path, h) for h in headers], +context = Clang.init( + headers=[joinpath(HEADER_BASE, HEADER_DIR, h) for h in headers], common_file="commons.jl", output_dir="../src/wrapper", - clang_includes=clang_includes, + clang_includes=vcat(HEADER_BASE, LLVM_INCLUDE), + clang_args = ["-I", HEADER_BASE], clang_diagnostics=true, - # do not wrap included headers header_wrapped=(header, cursorname) -> header == cursorname, header_library=header_name -> "libscip" ) - Clang.run(context) From 41c21f946785ec2f6b628f4c01d5547e291e32bb Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 20:52:02 +0100 Subject: [PATCH 09/82] no special order of type_* headers in generate_wrapper.jl --- gen/generate_wrapper.jl | 18 +----------------- 1 file changed, 1 insertion(+), 17 deletions(-) diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index f43144a0..fafb33e5 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -3,24 +3,8 @@ using Clang HEADER_BASE = "/usr/include" # using system-wide installation of SCIP HEADER_DIR = "scip" all_headers = readdir(joinpath(HEADER_BASE, HEADER_DIR)) -top_types = [ - "type_retcode.h", - "type_result.h", - "type_clock.h", - "type_misc.h", - "type_timing.h", - "type_paramset.h", - "type_event.h", - "type_lp.h", - "type_nlp.h", - "type_var.h", - "type_prob.h", - "type_tree.h", - "type_scip.h", -] headers = vcat( - top_types, - filter(h -> startswith(h, "type_") && !in(h, top_types), all_headers), + filter(h -> startswith(h, "type_"), all_headers), # filter(h -> startswith(h, "pub_"), all_headers), filter(h -> startswith(h, "scip_"), all_headers), ) From 92d368546c8697f7bf80500e5cdadd090cbc66cc Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 21:10:38 +0100 Subject: [PATCH 10/82] regenerate wrapper --- src/wrapper/CEnum.jl | 114 + src/wrapper/commons.jl | 4921 ++++++---------------------- src/wrapper/ctypes.jl | 7 + src/wrapper/scip_bandit.jl | 4 +- src/wrapper/scip_benders.jl | 34 +- src/wrapper/scip_branch.jl | 32 +- src/wrapper/scip_compr.jl | 8 +- src/wrapper/scip_concurrent.jl | 4 +- src/wrapper/scip_conflict.jl | 22 +- src/wrapper/scip_cons.jl | 62 +- src/wrapper/scip_copy.jl | 38 +- src/wrapper/scip_cut.jl | 14 +- src/wrapper/scip_datastructures.jl | 34 +- src/wrapper/scip_debug.jl | 2 +- src/wrapper/scip_dialog.jl | 4 +- src/wrapper/scip_disp.jl | 6 +- src/wrapper/scip_event.jl | 14 +- src/wrapper/scip_expr.jl | 6 +- src/wrapper/scip_general.jl | 4 +- src/wrapper/scip_heur.jl | 10 +- src/wrapper/scip_lp.jl | 58 +- src/wrapper/scip_mem.jl | 6 +- src/wrapper/scip_message.jl | 4 +- src/wrapper/scip_nlp.jl | 48 +- src/wrapper/scip_nodesel.jl | 10 +- src/wrapper/scip_nonlinear.jl | 20 +- src/wrapper/scip_numerics.jl | 150 +- src/wrapper/scip_param.jl | 58 +- src/wrapper/scip_presol.jl | 8 +- src/wrapper/scip_pricer.jl | 8 +- src/wrapper/scip_prob.jl | 32 +- src/wrapper/scip_probing.jl | 30 +- src/wrapper/scip_prop.jl | 12 +- src/wrapper/scip_randnumgen.jl | 8 +- src/wrapper/scip_reader.jl | 2 +- src/wrapper/scip_relax.jl | 8 +- src/wrapper/scip_reopt.jl | 28 +- src/wrapper/scip_sepa.jl | 8 +- src/wrapper/scip_sol.jl | 52 +- src/wrapper/scip_solve.jl | 12 +- src/wrapper/scip_solvingstats.jl | 32 +- src/wrapper/scip_table.jl | 4 +- src/wrapper/scip_timing.jl | 4 +- src/wrapper/scip_tree.jl | 4 +- src/wrapper/scip_validation.jl | 4 +- src/wrapper/scip_var.jl | 216 +- 46 files changed, 1763 insertions(+), 4403 deletions(-) create mode 100644 src/wrapper/CEnum.jl create mode 100644 src/wrapper/ctypes.jl diff --git a/src/wrapper/CEnum.jl b/src/wrapper/CEnum.jl new file mode 100644 index 00000000..8f5fe61d --- /dev/null +++ b/src/wrapper/CEnum.jl @@ -0,0 +1,114 @@ +module CEnum + +abstract type Cenum{T} end + +Base.:|(a::T, b::T) where {T<:Cenum{UInt32}} = UInt32(a) | UInt32(b) +Base.:&(a::T, b::T) where {T<:Cenum{UInt32}} = UInt32(a) & UInt32(b) +Base.:(==)(a::Integer, b::Cenum{T}) where {T<:Integer} = a == T(b) +Base.:(==)(a::Cenum, b::Integer) = b == a + +# typemin and typemax won't change for an enum, so we might as well inline them per type +Base.typemax(::Type{T}) where {T<:Cenum} = last(enum_values(T)) +Base.typemin(::Type{T}) where {T<:Cenum} = first(enum_values(T)) + +Base.convert(::Type{Integer}, x::Cenum{T}) where {T<:Integer} = Base.bitcast(T, x) +Base.convert(::Type{T}, x::Cenum{T2}) where {T<:Integer,T2<:Integer} = convert(T, Base.bitcast(T2, x)) + +(::Type{T})(x::Cenum{T2}) where {T<:Integer,T2<:Integer} = T(Base.bitcast(T2, x))::T +(::Type{T})(x) where {T<:Cenum} = convert(T, x) + +Base.write(io::IO, x::Cenum) = write(io, Int32(x)) +Base.read(io::IO, ::Type{T}) where {T<:Cenum} = T(read(io, Int32)) + +enum_values(::T) where {T<:Cenum} = enum_values(T) +enum_names(::T) where {T<:Cenum} = enum_names(T) + +is_member(::Type{T}, x::Integer) where {T<:Cenum} = is_member(T, enum_values(T), x) + +@inline is_member(::Type{T}, r::UnitRange, x::Integer) where {T<:Cenum} = x in r +@inline function is_member(::Type{T}, values::Tuple, x::Integer) where {T<:Cenum} + lo, hi = typemin(T), typemax(T) + xhi && return false + for val in values + val == x && return true + val > x && return false # is sorted + end + return false +end + +function enum_name(x::T) where {T<:Cenum} + index = something(findfirst(isequal(x), enum_values(T)), 0) + if index != 0 + return enum_names(T)[index] + end + error("Invalid enum: $(Int(x)), name not found") +end + +Base.show(io::IO, x::Cenum) = print(io, enum_name(x), "($(Int(x)))") + +function islinear(array) + isempty(array) && return false # false, really? it's kinda undefined? + lastval = first(array) + for val in Iterators.rest(array, 2) + val-lastval == 1 || return false + end + return true +end + + +macro cenum(name, args...) + if Meta.isexpr(name, :curly) + typename, type = name.args + typename = esc(typename) + typesize = 8*sizeof(getfield(Base, type)) + typedef_expr = :(primitive type $typename <: CEnum.Cenum{$type} $typesize end) + elseif isa(name, Symbol) + # default to UInt32 + typename = esc(name) + type = UInt32 + typedef_expr = :(primitive type $typename <: CEnum.Cenum{UInt32} 32 end) + else + error("Name must be symbol or Name{Type}. Found: $name") + end + lastval = -1 + name_values = map([args...]) do arg + if isa(arg, Symbol) + lastval += 1 + val = lastval + sym = arg + elseif arg.head == :(=) || arg.head == :kw + sym,val = arg.args + else + error("Expression of type $arg not supported. Try only symbol or name = value") + end + (sym, val) + end + sort!(name_values, by=last) # sort for values + values = map(last, name_values) + + if islinear(values) # optimize for linear values + values = :($(first(values)):$(last(values))) + else + values = :(tuple($(values...))) + end + value_block = Expr(:block) + + for (ename, value) in name_values + push!(value_block.args, :(const $(esc(ename)) = $typename($value))) + end + + expr = quote + $typedef_expr + function Base.convert(::Type{$typename}, x::Integer) + is_member($typename, x) || Base.Enums.enum_argument_error($(Expr(:quote, name)), x) + Base.bitcast($typename, convert($type, x)) + end + CEnum.enum_names(::Type{$typename}) = tuple($(map(x-> Expr(:quote, first(x)), name_values)...)) + CEnum.enum_values(::Type{$typename}) = $values + $value_block + end + expr +end +export @cenum + +end # module diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index 1badb1df..81863115 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -1,221 +1,973 @@ -# Automatically generated using Clang.jl wrap_c, version 0.0.0 - - -# begin enum SCIP_Retcode -const SCIP_Retcode = Cint -const SCIP_OKAY = 1 |> Int32 -const SCIP_ERROR = 0 |> Int32 -const SCIP_NOMEMORY = -1 |> Int32 -const SCIP_READERROR = -2 |> Int32 -const SCIP_WRITEERROR = -3 |> Int32 -const SCIP_NOFILE = -4 |> Int32 -const SCIP_FILECREATEERROR = -5 |> Int32 -const SCIP_LPERROR = -6 |> Int32 -const SCIP_NOPROBLEM = -7 |> Int32 -const SCIP_INVALIDCALL = -8 |> Int32 -const SCIP_INVALIDDATA = -9 |> Int32 -const SCIP_INVALIDRESULT = -10 |> Int32 -const SCIP_PLUGINNOTFOUND = -11 |> Int32 -const SCIP_PARAMETERUNKNOWN = -12 |> Int32 -const SCIP_PARAMETERWRONGTYPE = -13 |> Int32 -const SCIP_PARAMETERWRONGVAL = -14 |> Int32 -const SCIP_KEYALREADYEXISTING = -15 |> Int32 -const SCIP_MAXDEPTHLEVEL = -16 |> Int32 -const SCIP_BRANCHERROR = -17 |> Int32 -# end enum SCIP_Retcode +# Automatically generated using Clang.jl wrap_c -const SCIP_RETCODE = SCIP_Retcode - -# begin enum SCIP_Result -const SCIP_Result = UInt32 -const SCIP_DIDNOTRUN = 1 |> UInt32 -const SCIP_DELAYED = 2 |> UInt32 -const SCIP_DIDNOTFIND = 3 |> UInt32 -const SCIP_FEASIBLE = 4 |> UInt32 -const SCIP_INFEASIBLE = 5 |> UInt32 -const SCIP_UNBOUNDED = 6 |> UInt32 -const SCIP_CUTOFF = 7 |> UInt32 -const SCIP_SEPARATED = 8 |> UInt32 -const SCIP_NEWROUND = 9 |> UInt32 -const SCIP_REDUCEDDOM = 10 |> UInt32 -const SCIP_CONSADDED = 11 |> UInt32 -const SCIP_CONSCHANGED = 12 |> UInt32 -const SCIP_BRANCHED = 13 |> UInt32 -const SCIP_SOLVELP = 14 |> UInt32 -const SCIP_FOUNDSOL = 15 |> UInt32 -const SCIP_SUSPENDED = 16 |> UInt32 -const SCIP_SUCCESS = 17 |> UInt32 -const SCIP_DELAYNODE = 18 |> UInt32 -# end enum SCIP_Result - -const SCIP_RESULT = SCIP_Result - -# begin enum SCIP_ClockType -const SCIP_ClockType = UInt32 -const SCIP_CLOCKTYPE_DEFAULT = 0 |> UInt32 -const SCIP_CLOCKTYPE_CPU = 1 |> UInt32 -const SCIP_CLOCKTYPE_WALL = 2 |> UInt32 -# end enum SCIP_ClockType -const SCIP_CLOCKTYPE = SCIP_ClockType - -struct SCIP_Clock -end +# Skipping MacroDefinition: SCIP_DECL_BANDITFREE ( x ) SCIP_RETCODE x ( BMS_BLKMEM * blkmem , SCIP_BANDIT * bandit \ +#) +# Skipping MacroDefinition: SCIP_DECL_BANDITSELECT ( x ) SCIP_RETCODE x ( SCIP_BANDIT * bandit , int * selection \ +#) +# Skipping MacroDefinition: SCIP_DECL_BANDITUPDATE ( x ) SCIP_RETCODE x ( SCIP_BANDIT * bandit , int selection , SCIP_Real score \ +#) +# Skipping MacroDefinition: SCIP_DECL_BANDITRESET ( x ) SCIP_RETCODE x ( BMS_BUFMEM * bufmem , SCIP_BANDIT * bandit , SCIP_Real * priorities \ +#) + +const SCIP_Bandit = Cvoid +const SCIP_BANDIT = SCIP_Bandit +const SCIP_BanditVTable = Cvoid +const SCIP_BANDITVTABLE = SCIP_BanditVTable +const SCIP_BanditData = Cvoid +const SCIP_BANDITDATA = SCIP_BanditData + +# Skipping MacroDefinition: SCIP_DECL_BENDERSCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSCREATESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , int probnumber ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSPRESUBSOLVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , SCIP_BENDERSENFOTYPE type , SCIP_Bool checkint , SCIP_Bool * skipsolve , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSSOLVESUBCONVEX ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , int probnumber , SCIP_Bool onlyconvexcheck , SCIP_Real * objective , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSSOLVESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , int probnumber , SCIP_Real * objective , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSPOSTSOLVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , SCIP_BENDERSENFOTYPE type , int * mergecands , int npriomergecands , int nmergecands , SCIP_Bool checkint , SCIP_Bool infeasible , SCIP_Bool * merged ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSFREESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , int probnumber ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSGETVAR ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_VAR * var , SCIP_VAR * * mappedvar , int probnumber ) + +@cenum(SCIP_BendersEnfoType, + SCIP_BENDERSENFOTYPE_LP = 1, + SCIP_BENDERSENFOTYPE_RELAX = 2, + SCIP_BENDERSENFOTYPE_PSEUDO = 3, + SCIP_BENDERSENFOTYPE_CHECK = 4, +) -const SCIP_CLOCK = Cvoid +const SCIP_BENDERSENFOTYPE = SCIP_BendersEnfoType -struct SCIP_CPUClock -end +@cenum(SCIP_BendersSolveLoop, + SCIP_BENDERSSOLVELOOP_CONVEX = 0, + SCIP_BENDERSSOLVELOOP_CIP = 1, + SCIP_BENDERSSOLVELOOP_USERCONVEX = 2, + SCIP_BENDERSSOLVELOOP_USERCIP = 3, +) -const SCIP_CPUCLOCK = Cvoid +const SCIP_BENDERSSOLVELOOP = SCIP_BendersSolveLoop -struct SCIP_WallClock -end +@cenum(SCIP_BendersSubStatus, + SCIP_BENDERSSUBSTATUS_UNKNOWN = 0, + SCIP_BENDERSSUBSTATUS_OPTIMAL = 1, + SCIP_BENDERSSUBSTATUS_AUXVIOL = 2, + SCIP_BENDERSSUBSTATUS_INFEAS = 3, +) -const SCIP_WALLCLOCK = Cvoid +const SCIP_BENDERSSUBSTATUS = SCIP_BendersSubStatus +const SCIP_Benders = Cvoid +const SCIP_BENDERS = SCIP_Benders +const SCIP_BendersData = Cvoid +const SCIP_BENDERSDATA = SCIP_BendersData + +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_BENDERSCUT * benderscut ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) +# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_BENDERSCUT * benderscut , SCIP_SOL * sol , int probnumber , SCIP_BENDERSENFOTYPE type , SCIP_RESULT * result ) + +const SCIP_Benderscut = Cvoid +const SCIP_BENDERSCUT = SCIP_Benderscut +const SCIP_BenderscutData = Cvoid +const SCIP_BENDERSCUTDATA = SCIP_BenderscutData + +# Skipping MacroDefinition: SCIP_DECL_BRANCHCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) +# Skipping MacroDefinition: SCIP_DECL_BRANCHFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) +# Skipping MacroDefinition: SCIP_DECL_BRANCHINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) +# Skipping MacroDefinition: SCIP_DECL_BRANCHINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECEXT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECPS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) + +const SCIP_BranchCand = Cvoid +const SCIP_BRANCHCAND = SCIP_BranchCand +const SCIP_Branchrule = Cvoid +const SCIP_BRANCHRULE = SCIP_Branchrule +const SCIP_BranchruleData = Cvoid +const SCIP_BRANCHRULEDATA = SCIP_BranchruleData + +@cenum(SCIP_ClockType, + SCIP_CLOCKTYPE_DEFAULT = 0, + SCIP_CLOCKTYPE_CPU = 1, + SCIP_CLOCKTYPE_WALL = 2, +) -# Skipping MacroDefinition: SCIP_DECL_SORTINDCOMP ( x ) int x ( void * dataptr , int ind1 , int ind2 ) /** compares two data element pointers -# * result: -# * < 0: elem1 comes before (is better than) elem2 -# * = 0: both elements have the same value -# * > 0: elem2 comes after (is worse than) elem2 -# */ -# Skipping MacroDefinition: SCIP_DECL_SORTPTRCOMP ( x ) int x ( void * elem1 , void * elem2 ) /** gets the key of the given element */ -# Skipping MacroDefinition: SCIP_DECL_HASHGETKEY ( x ) void * x ( void * userptr , void * elem ) /** returns TRUE iff both keys are equal */ -# Skipping MacroDefinition: SCIP_DECL_HASHKEYEQ ( x ) SCIP_Bool x ( void * userptr , void * key1 , void * key2 ) /** returns the hash value of the key */ -# Skipping MacroDefinition: SCIP_DECL_HASHKEYVAL ( x ) uint64_t x ( void * userptr , void * key ) # +const SCIP_CLOCKTYPE = SCIP_ClockType +const SCIP_Clock = Cvoid +const SCIP_CLOCK = SCIP_Clock +const SCIP_CPUClock = Cvoid +const SCIP_CPUCLOCK = SCIP_CPUClock +const SCIP_WallClock = Cvoid +const SCIP_WALLCLOCK = SCIP_WallClock + +# Skipping MacroDefinition: SCIP_DECL_COMPRCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) +# Skipping MacroDefinition: SCIP_DECL_COMPRFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) +# Skipping MacroDefinition: SCIP_DECL_COMPRINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) +# Skipping MacroDefinition: SCIP_DECL_COMPREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) +# Skipping MacroDefinition: SCIP_DECL_COMPRINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) +# Skipping MacroDefinition: SCIP_DECL_COMPREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) +# Skipping MacroDefinition: SCIP_DECL_COMPREXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr , SCIP_RESULT * result ) + +const SCIP_Compr = Cvoid +const SCIP_COMPR = SCIP_Compr +const SCIP_ComprData = Cvoid +const SCIP_COMPRDATA = SCIP_ComprData + +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERCREATEINST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONCSOLVERTYPE * concsolvertype , SCIP_CONCSOLVER * concsolver ) +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERDESTROYINST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONCSOLVER * concsolver ) +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERTYPEFREEDATA ( x ) void x ( SCIP_CONCSOLVERTYPEDATA * * data ) +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERINITSEEDS ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , unsigned int seed ) +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSYNCWRITE ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_SYNCSTORE * syncstore , SCIP_SYNCDATA * syncdata , int maxcandsols , int maxsharedsols , int * nsolsshared ) +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSYNCREAD ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_SYNCSTORE * syncstore , SCIP_SYNCDATA * syncdata , int * nsolsrecvd , int * ntighterbnds , int * ntighterintbnds ) +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVEREXEC ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_Real * solvingtime , SCIP_Longint * nlpiterations , SCIP_Longint * nnodes ) +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSTOP ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver ) +# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP * scip ) + +const SCIP_ConcSolverType = Cvoid +const SCIP_CONCSOLVERTYPE = SCIP_ConcSolverType +const SCIP_ConcSolverTypeData = Cvoid +const SCIP_CONCSOLVERTYPEDATA = SCIP_ConcSolverTypeData +const SCIP_ConcSolver = Cvoid +const SCIP_CONCSOLVER = SCIP_ConcSolver +const SCIP_ConcSolverData = Cvoid +const SCIP_CONCSOLVERDATA = SCIP_ConcSolverData +const SCIP_Concurrent = Cvoid +const SCIP_CONCURRENT = SCIP_Concurrent + +# Skipping MacroDefinition: SCIP_DECL_CONFLICTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) +# Skipping MacroDefinition: SCIP_DECL_CONFLICTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) +# Skipping MacroDefinition: SCIP_DECL_CONFLICTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) +# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) +# Skipping MacroDefinition: SCIP_DECL_CONFLICTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) +# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) +# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr , SCIP_NODE * node , SCIP_NODE * validnode , SCIP_BDCHGINFO * * bdchginfos , SCIP_Real * relaxedbds , int nbdchginfos , SCIP_CONFTYPE conftype , SCIP_Bool cutoffinvolved , SCIP_Bool separate , SCIP_Bool local , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool resolved , SCIP_RESULT * result ) + +const SCIP_Conflicthdlr = Cvoid +const SCIP_CONFLICTHDLR = SCIP_Conflicthdlr +const SCIP_ConflicthdlrData = Cvoid +const SCIP_CONFLICTHDLRDATA = SCIP_ConflicthdlrData +const SCIP_ConflictSet = Cvoid +const SCIP_CONFLICTSET = SCIP_ConflictSet +const SCIP_ProofSet = Cvoid +const SCIP_PROOFSET = SCIP_ProofSet +const SCIP_LPBdChgs = Cvoid +const SCIP_LPBDCHGS = SCIP_LPBdChgs +const SCIP_Conflict = Cvoid +const SCIP_CONFLICT = SCIP_Conflict + +@cenum(SCIP_ConflictType, + SCIP_CONFTYPE_UNKNOWN = 0, + SCIP_CONFTYPE_PROPAGATION = 1, + SCIP_CONFTYPE_INFEASLP = 2, + SCIP_CONFTYPE_BNDEXCEEDING = 3, + SCIP_CONFTYPE_ALTINFPROOF = 4, + SCIP_CONFTYPE_ALTBNDPROOF = 5, +) -# begin enum SCIP_Confidencelevel -const SCIP_Confidencelevel = UInt32 -const SCIP_CONFIDENCELEVEL_MIN = 0 |> UInt32 -const SCIP_CONFIDENCELEVEL_LOW = 1 |> UInt32 -const SCIP_CONFIDENCELEVEL_MEDIUM = 2 |> UInt32 -const SCIP_CONFIDENCELEVEL_HIGH = 3 |> UInt32 -const SCIP_CONFIDENCELEVEL_MAX = 4 |> UInt32 -# end enum SCIP_Confidencelevel +const SCIP_CONFTYPE = SCIP_ConflictType -const SCIP_CONFIDENCELEVEL = SCIP_Confidencelevel +@cenum(SCIP_ConflictPresolStrat, + SCIP_CONFPRES_DISABLED = 0, + SCIP_CONFPRES_ONLYLOCAL = 1, + SCIP_CONFPRES_ONLYGLOBAL = 2, + SCIP_CONFPRES_BOTH = 3, +) -struct SCIP_SparseSol -end +const SCIP_CONFPRES = SCIP_ConflictPresolStrat +const SCIP_ConflictStore = Cvoid +const SCIP_CONFLICTSTORE = SCIP_ConflictStore + +# Skipping MacroDefinition: SCIP_NLINCONSTYPES ( ( int ) SCIP_LINCONSTYPE_GENERAL + 1 ) +# Skipping MacroDefinition: SCIP_DECL_CONSHDLRCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_Bool * valid ) +# Skipping MacroDefinition: SCIP_DECL_CONSFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr ) +# Skipping MacroDefinition: SCIP_DECL_CONSINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) +# Skipping MacroDefinition: SCIP_DECL_CONSEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) +# Skipping MacroDefinition: SCIP_DECL_CONSINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) +# Skipping MacroDefinition: SCIP_DECL_CONSEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) +# Skipping MacroDefinition: SCIP_DECL_CONSINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) +# Skipping MacroDefinition: SCIP_DECL_CONSEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_Bool restart ) +# Skipping MacroDefinition: SCIP_DECL_CONSDELETE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_CONSDATA * * consdata ) +# Skipping MacroDefinition: SCIP_DECL_CONSTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * sourcecons , SCIP_CONS * * targetcons ) +# Skipping MacroDefinition: SCIP_DECL_CONSINITLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_Bool * infeasible ) +# Skipping MacroDefinition: SCIP_DECL_CONSSEPALP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSSEPASOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_SOL * sol , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSENFOLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSENFORELAX ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SOL * sol , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSENFOPS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_Bool objinfeasible , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSCHECK ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_SOL * sol , SCIP_Bool checkintegrality , SCIP_Bool checklprows , SCIP_Bool printreason , SCIP_Bool completely , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , int nmarkedconss , SCIP_PROPTIMING proptiming , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSPRESOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSRESPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_VAR * infervar , int inferinfo , SCIP_BOUNDTYPE boundtype , SCIP_BDCHGIDX * bdchgidx , SCIP_Real relaxedbd , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_CONSLOCK ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_LOCKTYPE locktype , int nlockspos , int nlocksneg ) +# Skipping MacroDefinition: SCIP_DECL_CONSACTIVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) +# Skipping MacroDefinition: SCIP_DECL_CONSDEACTIVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) +# Skipping MacroDefinition: SCIP_DECL_CONSENABLE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) +# Skipping MacroDefinition: SCIP_DECL_CONSDISABLE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) +# Skipping MacroDefinition: SCIP_DECL_CONSDELVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) +# Skipping MacroDefinition: SCIP_DECL_CONSPRINT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , FILE * file ) +# Skipping MacroDefinition: SCIP_DECL_CONSCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONS * * cons , const char * name , SCIP * sourcescip , SCIP_CONSHDLR * sourceconshdlr , SCIP_CONS * sourcecons , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_Bool initial , SCIP_Bool separate , SCIP_Bool enforce , SCIP_Bool check , SCIP_Bool propagate , SCIP_Bool local , SCIP_Bool modifiable , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool stickingatnode , SCIP_Bool global , SCIP_Bool * valid ) +# Skipping MacroDefinition: SCIP_DECL_CONSPARSE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * cons , const char * name , const char * str , SCIP_Bool initial , SCIP_Bool separate , SCIP_Bool enforce , SCIP_Bool check , SCIP_Bool propagate , SCIP_Bool local , SCIP_Bool modifiable , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool stickingatnode , SCIP_Bool * success ) +# Skipping MacroDefinition: SCIP_DECL_CONSGETVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_VAR * * vars , int varssize , SCIP_Bool * success ) +# Skipping MacroDefinition: SCIP_DECL_CONSGETNVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , int * nvars , SCIP_Bool * success ) +# Skipping MacroDefinition: SCIP_DECL_CONSGETDIVEBDCHGS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_DIVESET * diveset , SCIP_SOL * sol , SCIP_Bool * success , SCIP_Bool * infeasible ) + +const SCIP_Conshdlr = Cvoid +const SCIP_CONSHDLR = SCIP_Conshdlr +const SCIP_Cons = Cvoid +const SCIP_CONS = SCIP_Cons +const SCIP_ConshdlrData = Cvoid +const SCIP_CONSHDLRDATA = SCIP_ConshdlrData +const SCIP_ConsData = Cvoid +const SCIP_CONSDATA = SCIP_ConsData +const SCIP_ConsSetChg = Cvoid +const SCIP_CONSSETCHG = SCIP_ConsSetChg +const SCIP_LinConsStats = Cvoid +const SCIP_LINCONSSTATS = SCIP_LinConsStats + +@cenum(SCIP_LinConstype, + SCIP_LINCONSTYPE_EMPTY = 0, + SCIP_LINCONSTYPE_FREE = 1, + SCIP_LINCONSTYPE_SINGLETON = 2, + SCIP_LINCONSTYPE_AGGREGATION = 3, + SCIP_LINCONSTYPE_PRECEDENCE = 4, + SCIP_LINCONSTYPE_VARBOUND = 5, + SCIP_LINCONSTYPE_SETPARTITION = 6, + SCIP_LINCONSTYPE_SETPACKING = 7, + SCIP_LINCONSTYPE_SETCOVERING = 8, + SCIP_LINCONSTYPE_CARDINALITY = 9, + SCIP_LINCONSTYPE_INVKNAPSACK = 10, + SCIP_LINCONSTYPE_EQKNAPSACK = 11, + SCIP_LINCONSTYPE_BINPACKING = 12, + SCIP_LINCONSTYPE_KNAPSACK = 13, + SCIP_LINCONSTYPE_INTKNAPSACK = 14, + SCIP_LINCONSTYPE_MIXEDBINARY = 15, + SCIP_LINCONSTYPE_GENERAL = 16, +) -const SCIP_SPARSESOL = Cvoid +const SCIP_LINCONSTYPE = SCIP_LinConstype +const SCIP_Cutpool = Cvoid +const SCIP_CUTPOOL = SCIP_Cutpool +const SCIP_Cut = Cvoid +const SCIP_CUT = SCIP_Cut +const SCIP_AggrRow = Cvoid +const SCIP_AGGRROW = SCIP_AggrRow + +# Skipping MacroDefinition: SCIP_DECL_DIALOGCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) +# Skipping MacroDefinition: SCIP_DECL_DIALOGFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) +# Skipping MacroDefinition: SCIP_DECL_DIALOGDESC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) +# Skipping MacroDefinition: SCIP_DECL_DIALOGEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog , SCIP_DIALOGHDLR * dialoghdlr , SCIP_DIALOG * * nextdialog ) + +const SCIP_Dialog = Cvoid +const SCIP_DIALOG = SCIP_Dialog +const SCIP_DialogData = Cvoid +const SCIP_DIALOGDATA = SCIP_DialogData +const SCIP_Dialoghdlr = Cvoid +const SCIP_DIALOGHDLR = SCIP_Dialoghdlr +const SCIP_Linelist = Cvoid +const SCIP_LINELIST = SCIP_Linelist + +# Skipping MacroDefinition: SCIP_DECL_DISPCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) +# Skipping MacroDefinition: SCIP_DECL_DISPFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) +# Skipping MacroDefinition: SCIP_DECL_DISPINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) +# Skipping MacroDefinition: SCIP_DECL_DISPEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) +# Skipping MacroDefinition: SCIP_DECL_DISPINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) +# Skipping MacroDefinition: SCIP_DECL_DISPEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) +# Skipping MacroDefinition: SCIP_DECL_DISPOUTPUT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp , FILE * file ) + +@cenum(SCIP_DispStatus, + SCIP_DISPSTATUS_OFF = 0, + SCIP_DISPSTATUS_AUTO = 1, + SCIP_DISPSTATUS_ON = 2, +) -struct SCIP_Queue -end +const SCIP_DISPSTATUS = SCIP_DispStatus -const SCIP_QUEUE = Cvoid +@cenum(SCIP_DispMode, + SCIP_DISPMODE_DEFAULT = 1, + SCIP_DISPMODE_CONCURRENT = 2, + SCIP_DISPMODE_ALL = 3, +) -struct SCIP_PQueue -end +const SCIP_DISPMODE = SCIP_DispMode +const SCIP_Disp = Cvoid +const SCIP_DISP = SCIP_Disp +const SCIP_DispData = Cvoid +const SCIP_DISPDATA = SCIP_DispData + +# Skipping MacroDefinition: SCIP_EVENTTYPE_DISABLED UINT64_C ( 0x00000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARADDED UINT64_C ( 0x00000001 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARDELETED UINT64_C ( 0x00000002 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARFIXED UINT64_C ( 0x00000004 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_VARUNLOCKED UINT64_C ( 0x00000008 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_OBJCHANGED UINT64_C ( 0x00000010 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_GLBCHANGED UINT64_C ( 0x00000020 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_GUBCHANGED UINT64_C ( 0x00000040 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_LBTIGHTENED UINT64_C ( 0x00000080 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_LBRELAXED UINT64_C ( 0x00000100 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_UBTIGHTENED UINT64_C ( 0x00000200 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_UBRELAXED UINT64_C ( 0x00000400 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_GHOLEADDED UINT64_C ( 0x00000800 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_GHOLEREMOVED UINT64_C ( 0x00001000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_LHOLEADDED UINT64_C ( 0x00002000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_LHOLEREMOVED UINT64_C ( 0x00004000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_IMPLADDED UINT64_C ( 0x00008000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_PRESOLVEROUND UINT64_C ( 0x00010000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEFOCUSED UINT64_C ( 0x00020000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEFEASIBLE UINT64_C ( 0x00040000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEINFEASIBLE UINT64_C ( 0x00080000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEBRANCHED UINT64_C ( 0x00100000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_FIRSTLPSOLVED UINT64_C ( 0x00200000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_LPSOLVED UINT64_C ( 0x00400000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_POORSOLFOUND UINT64_C ( 0x00800000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_BESTSOLFOUND UINT64_C ( 0x01000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWADDEDSEPA UINT64_C ( 0x02000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWDELETEDSEPA UINT64_C ( 0x04000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWADDEDLP UINT64_C ( 0x08000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWDELETEDLP UINT64_C ( 0x10000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWCOEFCHANGED UINT64_C ( 0x20000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWCONSTCHANGED UINT64_C ( 0x40000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWSIDECHANGED UINT64_C ( 0x80000000 ) +# Skipping MacroDefinition: SCIP_EVENTTYPE_SYNC UINT64_C ( 0x100000000 ) + +const SCIP_EVENTTYPE_GBDCHANGED = SCIP_EVENTTYPE_GLBCHANGED | SCIP_EVENTTYPE_GUBCHANGED +const SCIP_EVENTTYPE_LBCHANGED = SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED +const SCIP_EVENTTYPE_UBCHANGED = SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_UBRELAXED +const SCIP_EVENTTYPE_BOUNDTIGHTENED = SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_UBTIGHTENED +const SCIP_EVENTTYPE_BOUNDRELAXED = SCIP_EVENTTYPE_LBRELAXED | SCIP_EVENTTYPE_UBRELAXED +const SCIP_EVENTTYPE_BOUNDCHANGED = SCIP_EVENTTYPE_LBCHANGED | SCIP_EVENTTYPE_UBCHANGED +const SCIP_EVENTTYPE_GHOLECHANGED = SCIP_EVENTTYPE_GHOLEADDED | SCIP_EVENTTYPE_GHOLEREMOVED +const SCIP_EVENTTYPE_LHOLECHANGED = SCIP_EVENTTYPE_LHOLEADDED | SCIP_EVENTTYPE_LHOLEREMOVED +const SCIP_EVENTTYPE_HOLECHANGED = SCIP_EVENTTYPE_GHOLECHANGED | SCIP_EVENTTYPE_LHOLECHANGED +const SCIP_EVENTTYPE_DOMCHANGED = SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_HOLECHANGED +const SCIP_EVENTTYPE_VARCHANGED = (((((SCIP_EVENTTYPE_VARFIXED | SCIP_EVENTTYPE_VARUNLOCKED) | SCIP_EVENTTYPE_OBJCHANGED) | SCIP_EVENTTYPE_GBDCHANGED) | SCIP_EVENTTYPE_DOMCHANGED) | SCIP_EVENTTYPE_IMPLADDED) | SCIP_EVENTTYPE_VARDELETED +const SCIP_EVENTTYPE_VAREVENT = SCIP_EVENTTYPE_VARADDED | SCIP_EVENTTYPE_VARCHANGED +const SCIP_EVENTTYPE_NODESOLVED = (SCIP_EVENTTYPE_NODEFEASIBLE | SCIP_EVENTTYPE_NODEINFEASIBLE) | SCIP_EVENTTYPE_NODEBRANCHED +const SCIP_EVENTTYPE_NODEEVENT = SCIP_EVENTTYPE_NODEFOCUSED | SCIP_EVENTTYPE_NODESOLVED +const SCIP_EVENTTYPE_LPEVENT = SCIP_EVENTTYPE_FIRSTLPSOLVED | SCIP_EVENTTYPE_LPSOLVED +const SCIP_EVENTTYPE_SOLFOUND = SCIP_EVENTTYPE_POORSOLFOUND | SCIP_EVENTTYPE_BESTSOLFOUND +const SCIP_EVENTTYPE_SOLEVENT = SCIP_EVENTTYPE_SOLFOUND +const SCIP_EVENTTYPE_ROWCHANGED = (SCIP_EVENTTYPE_ROWCOEFCHANGED | SCIP_EVENTTYPE_ROWCONSTCHANGED) | SCIP_EVENTTYPE_ROWSIDECHANGED +const SCIP_EVENTTYPE_ROWEVENT = (((SCIP_EVENTTYPE_ROWADDEDSEPA | SCIP_EVENTTYPE_ROWDELETEDSEPA) | SCIP_EVENTTYPE_ROWADDEDLP) | SCIP_EVENTTYPE_ROWDELETEDLP) | SCIP_EVENTTYPE_ROWCHANGED +const SCIP_EVENTTYPE_FORMAT = PRIx64 -const SCIP_PQUEUE = Cvoid +# Skipping MacroDefinition: SCIP_DECL_EVENTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) +# Skipping MacroDefinition: SCIP_DECL_EVENTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) +# Skipping MacroDefinition: SCIP_DECL_EVENTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) +# Skipping MacroDefinition: SCIP_DECL_EVENTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) +# Skipping MacroDefinition: SCIP_DECL_EVENTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) +# Skipping MacroDefinition: SCIP_DECL_EVENTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) +# Skipping MacroDefinition: SCIP_DECL_EVENTDELETE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr , SCIP_EVENTDATA * * eventdata ) +# Skipping MacroDefinition: SCIP_DECL_EVENTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr , SCIP_EVENT * event , SCIP_EVENTDATA * eventdata ) -struct SCIP_HashTable -end +const SCIP_EVENTTYPE = UInt64 +const SCIP_Eventhdlr = Cvoid +const SCIP_EVENTHDLR = SCIP_Eventhdlr +const SCIP_EventhdlrData = Cvoid +const SCIP_EVENTHDLRDATA = SCIP_EventhdlrData +const SCIP_Event = Cvoid +const SCIP_EVENT = SCIP_Event +const SCIP_EventVarAdded = Cvoid +const SCIP_EVENTVARADDED = SCIP_EventVarAdded +const SCIP_EventVarDeleted = Cvoid +const SCIP_EVENTVARDELETED = SCIP_EventVarDeleted +const SCIP_EventVarFixed = Cvoid +const SCIP_EVENTVARFIXED = SCIP_EventVarFixed +const SCIP_EventVarUnlocked = Cvoid +const SCIP_EVENTVARUNLOCKED = SCIP_EventVarUnlocked +const SCIP_EventObjChg = Cvoid +const SCIP_EVENTOBJCHG = SCIP_EventObjChg +const SCIP_EventBdChg = Cvoid +const SCIP_EVENTBDCHG = SCIP_EventBdChg +const SCIP_EventHole = Cvoid +const SCIP_EVENTHOLE = SCIP_EventHole +const SCIP_EventImplAdd = Cvoid +const SCIP_EVENTIMPLADD = SCIP_EventImplAdd +const SCIP_EventRowAddedSepa = Cvoid +const SCIP_EVENTROWADDEDSEPA = SCIP_EventRowAddedSepa +const SCIP_EventRowDeletedSepa = Cvoid +const SCIP_EVENTROWDELETEDSEPA = SCIP_EventRowDeletedSepa +const SCIP_EventRowAddedLP = Cvoid +const SCIP_EVENTROWADDEDLP = SCIP_EventRowAddedLP +const SCIP_EventRowDeletedLP = Cvoid +const SCIP_EVENTROWDELETEDLP = SCIP_EventRowDeletedLP +const SCIP_EventRowCoefChanged = Cvoid +const SCIP_EVENTROWCOEFCHANGED = SCIP_EventRowCoefChanged +const SCIP_EventRowConstChanged = Cvoid +const SCIP_EVENTROWCONSTCHANGED = SCIP_EventRowConstChanged +const SCIP_EventRowSideChanged = Cvoid +const SCIP_EVENTROWSIDECHANGED = SCIP_EventRowSideChanged +const SCIP_EventData = Cvoid +const SCIP_EVENTDATA = SCIP_EventData +const SCIP_EventFilter = Cvoid +const SCIP_EVENTFILTER = SCIP_EventFilter +const SCIP_EventQueue = Cvoid +const SCIP_EVENTQUEUE = SCIP_EventQueue +const SCIP_DIVETYPE_NONE = UInt32(0x0000) +const SCIP_DIVETYPE_INTEGRALITY = UInt32(0x0001) +const SCIP_DIVETYPE_SOS1VARIABLE = UInt32(0x0002) -const SCIP_HASHTABLE = Cvoid +# Skipping MacroDefinition: SCIP_DECL_HEURCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) +# Skipping MacroDefinition: SCIP_DECL_HEURFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) +# Skipping MacroDefinition: SCIP_DECL_HEURINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) +# Skipping MacroDefinition: SCIP_DECL_HEUREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) +# Skipping MacroDefinition: SCIP_DECL_HEURINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) +# Skipping MacroDefinition: SCIP_DECL_HEUREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) +# Skipping MacroDefinition: SCIP_DECL_HEUREXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur , SCIP_HEURTIMING heurtiming , SCIP_Bool nodeinfeasible , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_DIVESETGETSCORE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIVESET * diveset , SCIP_DIVETYPE divetype , SCIP_VAR * cand , SCIP_Real candsol , SCIP_Real candsfrac , SCIP_Real * score , SCIP_Bool * roundup ) -struct SCIP_MultiHash -end +const SCIP_DIVETYPE = UInt32 +const SCIP_Heur = Cvoid +const SCIP_HEUR = SCIP_Heur +const SCIP_HeurData = Cvoid +const SCIP_HEURDATA = SCIP_HeurData +const SCIP_Diveset = Cvoid +const SCIP_DIVESET = SCIP_Diveset +const SCIP_VGraph = Cvoid +const SCIP_VGRAPH = SCIP_VGraph + +@cenum(SCIP_BranchDir, + SCIP_BRANCHDIR_DOWNWARDS = 0, + SCIP_BRANCHDIR_UPWARDS = 1, + SCIP_BRANCHDIR_FIXED = 2, + SCIP_BRANCHDIR_AUTO = 3, +) -const SCIP_MULTIHASH = Cvoid +const SCIP_BRANCHDIR = SCIP_BranchDir +const SCIP_History = Cvoid +const SCIP_HISTORY = SCIP_History +const SCIP_ValueHistory = Cvoid +const SCIP_VALUEHISTORY = SCIP_ValueHistory +const SCIP_VBounds = Cvoid +const SCIP_VBOUNDS = SCIP_VBounds +const SCIP_Implics = Cvoid +const SCIP_IMPLICS = SCIP_Implics +const SCIP_Clique = Cvoid +const SCIP_CLIQUE = SCIP_Clique +const SCIP_CliqueTable = Cvoid +const SCIP_CLIQUETABLE = SCIP_CliqueTable +const SCIP_CliqueList = Cvoid +const SCIP_CLIQUELIST = SCIP_CliqueList +const SCIP_Interrupt = Cvoid +const SCIP_INTERRUPT = SCIP_Interrupt + +@cenum(SCIP_LPSolStat, + SCIP_LPSOLSTAT_NOTSOLVED = 0, + SCIP_LPSOLSTAT_OPTIMAL = 1, + SCIP_LPSOLSTAT_INFEASIBLE = 2, + SCIP_LPSOLSTAT_UNBOUNDEDRAY = 3, + SCIP_LPSOLSTAT_OBJLIMIT = 4, + SCIP_LPSOLSTAT_ITERLIMIT = 5, + SCIP_LPSOLSTAT_TIMELIMIT = 6, + SCIP_LPSOLSTAT_ERROR = 7, +) -struct SCIP_MultiHashList -end +const SCIP_LPSOLSTAT = SCIP_LPSolStat -const SCIP_MULTIHASHLIST = Cvoid +@cenum(SCIP_BoundType, + SCIP_BOUNDTYPE_LOWER = 0, + SCIP_BOUNDTYPE_UPPER = 1, +) -struct SCIP_HashMapEntry -end +const SCIP_BOUNDTYPE = SCIP_BoundType -const SCIP_HASHMAPENTRY = Cvoid +@cenum(SCIP_SideType, + SCIP_SIDETYPE_LEFT = 0, + SCIP_SIDETYPE_RIGHT = 1, +) -struct SCIP_HashMap -end +const SCIP_SIDETYPE = SCIP_SideType -const SCIP_HASHMAP = Cvoid +@cenum(SCIP_RowOriginType, + SCIP_ROWORIGINTYPE_UNSPEC = 0, + SCIP_ROWORIGINTYPE_CONS = 1, + SCIP_ROWORIGINTYPE_SEPA = 2, + SCIP_ROWORIGINTYPE_REOPT = 3, +) -struct SCIP_HashSet -end +const SCIP_ROWORIGINTYPE = SCIP_RowOriginType -const SCIP_HASHSET = Cvoid +@cenum(SCIP_LPAlgo, + SCIP_LPALGO_PRIMALSIMPLEX = 0, + SCIP_LPALGO_DUALSIMPLEX = 1, + SCIP_LPALGO_BARRIER = 2, + SCIP_LPALGO_BARRIERCROSSOVER = 3, +) -struct SCIP_RealArray -end +const SCIP_LPALGO = SCIP_LPAlgo +const SCIP_ColSolVals = Cvoid +const SCIP_COLSOLVALS = SCIP_ColSolVals +const SCIP_RowSolVals = Cvoid +const SCIP_ROWSOLVALS = SCIP_RowSolVals +const SCIP_LpSolVals = Cvoid +const SCIP_LPSOLVALS = SCIP_LpSolVals +const SCIP_Col = Cvoid +const SCIP_COL = SCIP_Col +const SCIP_Row = Cvoid +const SCIP_ROW = SCIP_Row +const SCIP_Lp = Cvoid +const SCIP_LP = SCIP_Lp +const SCIP_Matrix = Cvoid +const SCIP_MATRIX = SCIP_Matrix +const SCIP_Mem = Cvoid +const SCIP_MEM = SCIP_Mem + +# Skipping MacroDefinition: SCIP_DECL_MESSAGEOUTPUTFUNC ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) +# Skipping MacroDefinition: SCIP_DECL_ERRORPRINTING ( x ) void x ( void * data , FILE * file , const char * msg ) +# Skipping MacroDefinition: SCIP_DECL_MESSAGEWARNING ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) +# Skipping MacroDefinition: SCIP_DECL_MESSAGEDIALOG ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) +# Skipping MacroDefinition: SCIP_DECL_MESSAGEINFO ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) +# Skipping MacroDefinition: SCIP_DECL_MESSAGEHDLRFREE ( x ) SCIP_RETCODE x ( SCIP_MESSAGEHDLR * messagehdlr ) + +@cenum(SCIP_VerbLevel, + SCIP_VERBLEVEL_NONE = 0, + SCIP_VERBLEVEL_DIALOG = 1, + SCIP_VERBLEVEL_MINIMAL = 2, + SCIP_VERBLEVEL_NORMAL = 3, + SCIP_VERBLEVEL_HIGH = 4, + SCIP_VERBLEVEL_FULL = 5, +) -const SCIP_REALARRAY = Cvoid +const SCIP_VERBLEVEL = SCIP_VerbLevel +const SCIP_Messagehdlr = Cvoid +const SCIP_MESSAGEHDLR = SCIP_Messagehdlr +const SCIP_MessagehdlrData = Cvoid +const SCIP_MESSAGEHDLRDATA = SCIP_MessagehdlrData + +# Skipping MacroDefinition: SCIP_DECL_SORTINDCOMP ( x ) int x ( void * dataptr , int ind1 , int ind2 ) +# Skipping MacroDefinition: SCIP_DECL_SORTPTRCOMP ( x ) int x ( void * elem1 , void * elem2 ) +# Skipping MacroDefinition: SCIP_DECL_HASHGETKEY ( x ) void * x ( void * userptr , void * elem ) +# Skipping MacroDefinition: SCIP_DECL_HASHKEYEQ ( x ) SCIP_Bool x ( void * userptr , void * key1 , void * key2 ) +# Skipping MacroDefinition: SCIP_DECL_HASHKEYVAL ( x ) uint64_t x ( void * userptr , void * key ) + +@cenum(SCIP_Confidencelevel, + SCIP_CONFIDENCELEVEL_MIN = 0, + SCIP_CONFIDENCELEVEL_LOW = 1, + SCIP_CONFIDENCELEVEL_MEDIUM = 2, + SCIP_CONFIDENCELEVEL_HIGH = 3, + SCIP_CONFIDENCELEVEL_MAX = 4, +) -struct SCIP_IntArray -end +const SCIP_CONFIDENCELEVEL = SCIP_Confidencelevel +const SCIP_SparseSol = Cvoid +const SCIP_SPARSESOL = SCIP_SparseSol +const SCIP_Queue = Cvoid +const SCIP_QUEUE = SCIP_Queue +const SCIP_PQueue = Cvoid +const SCIP_PQUEUE = SCIP_PQueue +const SCIP_HashTable = Cvoid +const SCIP_HASHTABLE = SCIP_HashTable +const SCIP_MultiHash = Cvoid +const SCIP_MULTIHASH = SCIP_MultiHash +const SCIP_MultiHashList = Cvoid +const SCIP_MULTIHASHLIST = SCIP_MultiHashList +const SCIP_HashMapEntry = Cvoid +const SCIP_HASHMAPENTRY = SCIP_HashMapEntry +const SCIP_HashMap = Cvoid +const SCIP_HASHMAP = SCIP_HashMap +const SCIP_HashSet = Cvoid +const SCIP_HASHSET = SCIP_HashSet +const SCIP_RealArray = Cvoid +const SCIP_REALARRAY = SCIP_RealArray +const SCIP_IntArray = Cvoid +const SCIP_INTARRAY = SCIP_IntArray +const SCIP_BoolArray = Cvoid +const SCIP_BOOLARRAY = SCIP_BoolArray +const SCIP_PtrArray = Cvoid +const SCIP_PTRARRAY = SCIP_PtrArray +const SCIP_RandNumGen = Cvoid +const SCIP_RANDNUMGEN = SCIP_RandNumGen +const SCIP_ResourceActivity = Cvoid +const SCIP_RESOURCEACTIVITY = SCIP_ResourceActivity +const SCIP_Profile = Cvoid +const SCIP_PROFILE = SCIP_Profile +const SCIP_Digraph = Cvoid +const SCIP_DIGRAPH = SCIP_Digraph +const SCIP_Bt = Cvoid +const SCIP_BT = SCIP_Bt +const SCIP_BtNode = Cvoid +const SCIP_BTNODE = SCIP_BtNode +const SCIP_Regression = Cvoid +const SCIP_REGRESSION = SCIP_Regression +const SCIP_DisjointSet = Cvoid +const SCIP_DISJOINTSET = SCIP_DisjointSet +const SCIP_NlRow = Cvoid +const SCIP_NLROW = SCIP_NlRow +const SCIP_Nlp = Cvoid +const SCIP_NLP = SCIP_Nlp + +# Skipping MacroDefinition: SCIP_DECL_NODESELCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) +# Skipping MacroDefinition: SCIP_DECL_NODESELFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) +# Skipping MacroDefinition: SCIP_DECL_NODESELINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) +# Skipping MacroDefinition: SCIP_DECL_NODESELEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) +# Skipping MacroDefinition: SCIP_DECL_NODESELINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) +# Skipping MacroDefinition: SCIP_DECL_NODESELEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) +# Skipping MacroDefinition: SCIP_DECL_NODESELSELECT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel , SCIP_NODE * * selnode ) +# Skipping MacroDefinition: SCIP_DECL_NODESELCOMP ( x ) int x ( SCIP * scip , SCIP_NODESEL * nodesel , SCIP_NODE * node1 , SCIP_NODE * node2 ) + +const SCIP_NodePQ = Cvoid +const SCIP_NODEPQ = SCIP_NodePQ +const SCIP_Nodesel = Cvoid +const SCIP_NODESEL = SCIP_Nodesel +const SCIP_NodeselData = Cvoid +const SCIP_NODESELDATA = SCIP_NodeselData + +# Skipping MacroDefinition: SCIP_DECL_PARAMCHGD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PARAM * param ) + +@cenum(SCIP_ParamType, + SCIP_PARAMTYPE_BOOL = 0, + SCIP_PARAMTYPE_INT = 1, + SCIP_PARAMTYPE_LONGINT = 2, + SCIP_PARAMTYPE_REAL = 3, + SCIP_PARAMTYPE_CHAR = 4, + SCIP_PARAMTYPE_STRING = 5, +) -const SCIP_INTARRAY = Cvoid +const SCIP_PARAMTYPE = SCIP_ParamType -struct SCIP_BoolArray -end +@cenum(SCIP_ParamSetting, + SCIP_PARAMSETTING_DEFAULT = 0, + SCIP_PARAMSETTING_AGGRESSIVE = 1, + SCIP_PARAMSETTING_FAST = 2, + SCIP_PARAMSETTING_OFF = 3, +) -const SCIP_BOOLARRAY = Cvoid +const SCIP_PARAMSETTING = SCIP_ParamSetting -struct SCIP_PtrArray -end +@cenum(SCIP_ParamEmphasis, + SCIP_PARAMEMPHASIS_DEFAULT = 0, + SCIP_PARAMEMPHASIS_CPSOLVER = 1, + SCIP_PARAMEMPHASIS_EASYCIP = 2, + SCIP_PARAMEMPHASIS_FEASIBILITY = 3, + SCIP_PARAMEMPHASIS_HARDLP = 4, + SCIP_PARAMEMPHASIS_OPTIMALITY = 5, + SCIP_PARAMEMPHASIS_COUNTER = 6, + SCIP_PARAMEMPHASIS_PHASEFEAS = 7, + SCIP_PARAMEMPHASIS_PHASEIMPROVE = 8, + SCIP_PARAMEMPHASIS_PHASEPROOF = 9, +) -const SCIP_PTRARRAY = Cvoid +const SCIP_PARAMEMPHASIS = SCIP_ParamEmphasis +const SCIP_Param = Cvoid +const SCIP_PARAM = SCIP_Param +const SCIP_ParamData = Cvoid +const SCIP_PARAMDATA = SCIP_ParamData +const SCIP_ParamSet = Cvoid +const SCIP_PARAMSET = SCIP_ParamSet + +# Skipping MacroDefinition: SCIP_DECL_PRESOLCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) +# Skipping MacroDefinition: SCIP_DECL_PRESOLFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) +# Skipping MacroDefinition: SCIP_DECL_PRESOLINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) +# Skipping MacroDefinition: SCIP_DECL_PRESOLEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) +# Skipping MacroDefinition: SCIP_DECL_PRESOLINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) +# Skipping MacroDefinition: SCIP_DECL_PRESOLEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) +# Skipping MacroDefinition: SCIP_DECL_PRESOLEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) + +const SCIP_Presol = Cvoid +const SCIP_PRESOL = SCIP_Presol +const SCIP_PresolData = Cvoid +const SCIP_PRESOLDATA = SCIP_PresolData + +# Skipping MacroDefinition: SCIP_DECL_PRICERCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_Bool * valid ) +# Skipping MacroDefinition: SCIP_DECL_PRICERFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) +# Skipping MacroDefinition: SCIP_DECL_PRICERINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) +# Skipping MacroDefinition: SCIP_DECL_PRICEREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) +# Skipping MacroDefinition: SCIP_DECL_PRICERINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) +# Skipping MacroDefinition: SCIP_DECL_PRICEREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) +# Skipping MacroDefinition: SCIP_DECL_PRICERREDCOST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_Real * lowerbound , SCIP_Bool * stopearly , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_PRICERFARKAS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_RESULT * result ) + +const SCIP_Pricer = Cvoid +const SCIP_PRICER = SCIP_Pricer +const SCIP_PricerData = Cvoid +const SCIP_PRICERDATA = SCIP_PricerData +const SCIP_Pricestore = Cvoid +const SCIP_PRICESTORE = SCIP_Pricestore +const SCIP_Primal = Cvoid +const SCIP_PRIMAL = SCIP_Primal + +# Skipping MacroDefinition: SCIP_DECL_PROBDELORIG ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * * probdata ) +# Skipping MacroDefinition: SCIP_DECL_PROBTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * sourcedata , SCIP_PROBDATA * * targetdata ) +# Skipping MacroDefinition: SCIP_DECL_PROBDELTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * * probdata ) +# Skipping MacroDefinition: SCIP_DECL_PROBINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * probdata ) +# Skipping MacroDefinition: SCIP_DECL_PROBEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * probdata , SCIP_Bool restart ) +# Skipping MacroDefinition: SCIP_DECL_PROBCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP * sourcescip , SCIP_PROBDATA * sourcedata , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_PROBDATA * * targetdata , SCIP_Bool global , SCIP_RESULT * result ) + +@cenum(SCIP_Objsense{Int32}, + SCIP_OBJSENSE_MAXIMIZE = -1, + SCIP_OBJSENSE_MINIMIZE = 1, +) -struct SCIP_RandNumGen -end +const SCIP_OBJSENSE = SCIP_Objsense +const SCIP_Prob = Cvoid +const SCIP_PROB = SCIP_Prob +const SCIP_ProbData = Cvoid +const SCIP_PROBDATA = SCIP_ProbData + +# Skipping MacroDefinition: SCIP_DECL_PROPCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) +# Skipping MacroDefinition: SCIP_DECL_PROPFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) +# Skipping MacroDefinition: SCIP_DECL_PROPINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) +# Skipping MacroDefinition: SCIP_DECL_PROPEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) +# Skipping MacroDefinition: SCIP_DECL_PROPINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) +# Skipping MacroDefinition: SCIP_DECL_PROPEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) +# Skipping MacroDefinition: SCIP_DECL_PROPINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) +# Skipping MacroDefinition: SCIP_DECL_PROPEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_Bool restart ) +# Skipping MacroDefinition: SCIP_DECL_PROPPRESOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_PROPEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_PROPTIMING proptiming , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_PROPRESPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_VAR * infervar , int inferinfo , SCIP_BOUNDTYPE boundtype , SCIP_BDCHGIDX * bdchgidx , SCIP_Real relaxedbd , SCIP_RESULT * result ) + +const SCIP_Prop = Cvoid +const SCIP_PROP = SCIP_Prop +const SCIP_PropData = Cvoid +const SCIP_PROPDATA = SCIP_PropData + +# Skipping MacroDefinition: SCIP_DECL_READERCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader ) +# Skipping MacroDefinition: SCIP_DECL_READERFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader ) +# Skipping MacroDefinition: SCIP_DECL_READERREAD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader , const char * filename , SCIP_RESULT * result ) +# Skipping MacroDefinition: SCIP_DECL_READERWRITE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader , FILE * file , const char * name , SCIP_PROBDATA * probdata , SCIP_Bool transformed , SCIP_OBJSENSE objsense , SCIP_Real objscale , SCIP_Real objoffset , SCIP_VAR * * vars , int nvars , int nbinvars , int nintvars , int nimplvars , int ncontvars , SCIP_VAR * * fixedvars , int nfixedvars , int startnvars , SCIP_CONS * * conss , int nconss , int maxnconss , int startnconss , SCIP_Bool genericnames , SCIP_RESULT * result ) + +const SCIP_Reader = Cvoid +const SCIP_READER = SCIP_Reader +const SCIP_ReaderData = Cvoid +const SCIP_READERDATA = SCIP_ReaderData + +# Skipping MacroDefinition: SCIP_DECL_RELAXCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) +# Skipping MacroDefinition: SCIP_DECL_RELAXFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) +# Skipping MacroDefinition: SCIP_DECL_RELAXINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) +# Skipping MacroDefinition: SCIP_DECL_RELAXEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) +# Skipping MacroDefinition: SCIP_DECL_RELAXINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) +# Skipping MacroDefinition: SCIP_DECL_RELAXEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) +# Skipping MacroDefinition: SCIP_DECL_RELAXEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax , SCIP_Real * lowerbound , SCIP_RESULT * result ) + +const SCIP_Relax = Cvoid +const SCIP_RELAX = SCIP_Relax +const SCIP_Relaxation = Cvoid +const SCIP_RELAXATION = SCIP_Relaxation +const SCIP_RelaxData = Cvoid +const SCIP_RELAXDATA = SCIP_RelaxData +const SCIP_Reopt = Cvoid +const SCIP_REOPT = SCIP_Reopt +const SCIP_SolTree = Cvoid +const SCIP_SOLTREE = SCIP_SolTree +const SCIP_SolNode = Cvoid +const SCIP_SOLNODE = SCIP_SolNode +const SCIP_ReoptTree = Cvoid +const SCIP_REOPTTREE = SCIP_ReoptTree +const SCIP_ReoptNode = Cvoid +const SCIP_REOPTNODE = SCIP_ReoptNode +const SCIP_REPRESENTATIVE = SCIP_ReoptNode +const SCIP_ReoptConsData = Cvoid +const SCIP_REOPTCONSDATA = SCIP_ReoptConsData + +@cenum(SCIP_ReoptType, + SCIP_REOPTTYPE_NONE = 0, + SCIP_REOPTTYPE_TRANSIT = 1, + SCIP_REOPTTYPE_INFSUBTREE = 2, + SCIP_REOPTTYPE_STRBRANCHED = 3, + SCIP_REOPTTYPE_LOGICORNODE = 4, + SCIP_REOPTTYPE_LEAF = 5, + SCIP_REOPTTYPE_PRUNED = 6, + SCIP_REOPTTYPE_FEASIBLE = 7, +) -const SCIP_RANDNUMGEN = Cvoid +const SCIP_REOPTTYPE = SCIP_ReoptType -struct SCIP_ResourceActivity -end +@cenum(Reopt_ConsType, + REOPT_CONSTYPE_INFSUBTREE = 0, + REOPT_CONSTYPE_DUALREDS = 1, + REOPT_CONSTYPE_CUT = 2, + REOPT_CONSTYPE_UNKNOWN = 3, +) -const SCIP_RESOURCEACTIVITY = Cvoid +const REOPT_CONSTYPE = Reopt_ConsType -struct SCIP_Profile -end +@cenum(SCIP_Result, + SCIP_DIDNOTRUN = 1, + SCIP_DELAYED = 2, + SCIP_DIDNOTFIND = 3, + SCIP_FEASIBLE = 4, + SCIP_INFEASIBLE = 5, + SCIP_UNBOUNDED = 6, + SCIP_CUTOFF = 7, + SCIP_SEPARATED = 8, + SCIP_NEWROUND = 9, + SCIP_REDUCEDDOM = 10, + SCIP_CONSADDED = 11, + SCIP_CONSCHANGED = 12, + SCIP_BRANCHED = 13, + SCIP_SOLVELP = 14, + SCIP_FOUNDSOL = 15, + SCIP_SUSPENDED = 16, + SCIP_SUCCESS = 17, + SCIP_DELAYNODE = 18, +) -const SCIP_PROFILE = Cvoid +const SCIP_RESULT = SCIP_Result -struct SCIP_Digraph -end +@cenum(SCIP_Retcode{Int32}, + SCIP_OKAY = 1, + SCIP_ERROR = 0, + SCIP_NOMEMORY = -1, + SCIP_READERROR = -2, + SCIP_WRITEERROR = -3, + SCIP_NOFILE = -4, + SCIP_FILECREATEERROR = -5, + SCIP_LPERROR = -6, + SCIP_NOPROBLEM = -7, + SCIP_INVALIDCALL = -8, + SCIP_INVALIDDATA = -9, + SCIP_INVALIDRESULT = -10, + SCIP_PLUGINNOTFOUND = -11, + SCIP_PARAMETERUNKNOWN = -12, + SCIP_PARAMETERWRONGTYPE = -13, + SCIP_PARAMETERWRONGVAL = -14, + SCIP_KEYALREADYEXISTING = -15, + SCIP_MAXDEPTHLEVEL = -16, + SCIP_BRANCHERROR = -17, +) -const SCIP_DIGRAPH = Cvoid +const SCIP_RETCODE = SCIP_Retcode +const Scip = Cvoid +const SCIP = Scip + +# Skipping MacroDefinition: SCIP_DECL_SEPACOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) +# Skipping MacroDefinition: SCIP_DECL_SEPAFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) +# Skipping MacroDefinition: SCIP_DECL_SEPAINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) +# Skipping MacroDefinition: SCIP_DECL_SEPAEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) +# Skipping MacroDefinition: SCIP_DECL_SEPAINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) +# Skipping MacroDefinition: SCIP_DECL_SEPAEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) +# Skipping MacroDefinition: SCIP_DECL_SEPAEXECLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa , SCIP_RESULT * result , SCIP_Bool allowlocal ) +# Skipping MacroDefinition: SCIP_DECL_SEPAEXECSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa , SCIP_SOL * sol , SCIP_RESULT * result , SCIP_Bool allowlocal ) + +const SCIP_Sepa = Cvoid +const SCIP_SEPA = SCIP_Sepa +const SCIP_SepaData = Cvoid +const SCIP_SEPADATA = SCIP_SepaData + +@cenum(SCIP_Efficiacychoice, + SCIP_EFFICIACYCHOICE_LP = 0, + SCIP_EFFICIACYCHOICE_RELAX = 1, + SCIP_EFFICIACYCHOICE_NLP = 2, +) -struct SCIP_Bt -end +const SCIP_EFFICIACYCHOICE = SCIP_Efficiacychoice +const SCIP_SepaStore = Cvoid +const SCIP_SEPASTORE = SCIP_SepaStore + +@cenum(SCIP_Stage, + SCIP_STAGE_INIT = 0, + SCIP_STAGE_PROBLEM = 1, + SCIP_STAGE_TRANSFORMING = 2, + SCIP_STAGE_TRANSFORMED = 3, + SCIP_STAGE_INITPRESOLVE = 4, + SCIP_STAGE_PRESOLVING = 5, + SCIP_STAGE_EXITPRESOLVE = 6, + SCIP_STAGE_PRESOLVED = 7, + SCIP_STAGE_INITSOLVE = 8, + SCIP_STAGE_SOLVING = 9, + SCIP_STAGE_SOLVED = 10, + SCIP_STAGE_EXITSOLVE = 11, + SCIP_STAGE_FREETRANS = 12, + SCIP_STAGE_FREE = 13, +) -const SCIP_BT = Cvoid +const SCIP_STAGE = SCIP_Stage -struct SCIP_BtNode -end +@cenum(SCIP_Setting, + SCIP_UNDEFINED = 0, + SCIP_DISABLED = 1, + SCIP_AUTO = 2, + SCIP_ENABLED = 3, +) -const SCIP_BTNODE = Cvoid +const SCIP_SETTING = SCIP_Setting +const SCIP_Set = Cvoid +const SCIP_SET = SCIP_Set + +@cenum(SCIP_SolOrigin, + SCIP_SOLORIGIN_ORIGINAL = 0, + SCIP_SOLORIGIN_ZERO = 1, + SCIP_SOLORIGIN_LPSOL = 2, + SCIP_SOLORIGIN_NLPSOL = 3, + SCIP_SOLORIGIN_RELAXSOL = 4, + SCIP_SOLORIGIN_PSEUDOSOL = 5, + SCIP_SOLORIGIN_PARTIAL = 6, + SCIP_SOLORIGIN_UNKNOWN = 7, +) -struct SCIP_Regression -end +const SCIP_SOLORIGIN = SCIP_SolOrigin +const SCIP_Sol = Cvoid +const SCIP_SOL = SCIP_Sol +const SCIP_Viol = Cvoid +const SCIP_VIOL = SCIP_Viol + +@cenum(SCIP_Status, + SCIP_STATUS_UNKNOWN = 0, + SCIP_STATUS_USERINTERRUPT = 1, + SCIP_STATUS_NODELIMIT = 2, + SCIP_STATUS_TOTALNODELIMIT = 3, + SCIP_STATUS_STALLNODELIMIT = 4, + SCIP_STATUS_TIMELIMIT = 5, + SCIP_STATUS_MEMLIMIT = 6, + SCIP_STATUS_GAPLIMIT = 7, + SCIP_STATUS_SOLLIMIT = 8, + SCIP_STATUS_BESTSOLLIMIT = 9, + SCIP_STATUS_RESTARTLIMIT = 10, + SCIP_STATUS_OPTIMAL = 11, + SCIP_STATUS_INFEASIBLE = 12, + SCIP_STATUS_UNBOUNDED = 13, + SCIP_STATUS_INFORUNBD = 14, + SCIP_STATUS_TERMINATE = 15, +) -const SCIP_REGRESSION = Cvoid +const SCIP_STATUS = SCIP_Status +const SCIP_Stat = Cvoid +const SCIP_STAT = SCIP_Stat -struct SCIP_DisjointSet -end +@cenum(SCIP_Parallelmode, + SCIP_PARA_OPPORTUNISTIC = 0, + SCIP_PARA_DETERMINISTIC = 1, +) -const SCIP_DISJOINTSET = Cvoid +const SCIP_PARALLELMODE = SCIP_Parallelmode +const SCIP_SyncStore = Cvoid +const SCIP_SYNCSTORE = SCIP_SyncStore +const SCIP_SyncData = Cvoid +const SCIP_SYNCDATA = SCIP_SyncData +const SCIP_BoundStore = Cvoid +const SCIP_BOUNDSTORE = SCIP_BoundStore + +# Skipping MacroDefinition: SCIP_DECL_TABLECOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) +# Skipping MacroDefinition: SCIP_DECL_TABLEFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) +# Skipping MacroDefinition: SCIP_DECL_TABLEINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) +# Skipping MacroDefinition: SCIP_DECL_TABLEEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) +# Skipping MacroDefinition: SCIP_DECL_TABLEINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) +# Skipping MacroDefinition: SCIP_DECL_TABLEEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) +# Skipping MacroDefinition: SCIP_DECL_TABLEOUTPUT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table , FILE * file ) + +const SCIP_Table = Cvoid +const SCIP_TABLE = SCIP_Table +const SCIP_TableData = Cvoid +const SCIP_TABLEDATA = SCIP_TableData const SCIP_PRESOLTIMING_NONE = UInt32(0x0002) const SCIP_PRESOLTIMING_FAST = UInt32(0x0004) const SCIP_PRESOLTIMING_MEDIUM = UInt32(0x0008) const SCIP_PRESOLTIMING_EXHAUSTIVE = UInt32(0x0010) const SCIP_PRESOLTIMING_FINAL = UInt32(0x0020) - -# Skipping MacroDefinition: SCIP_PRESOLTIMING_ALWAYS ( SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM | SCIP_PRESOLTIMING_EXHAUSTIVE ) # -# Skipping MacroDefinition: SCIP_PRESOLTIMING_MAX ( SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM | SCIP_PRESOLTIMING_EXHAUSTIVE | SCIP_PRESOLTIMING_FINAL ) typedef - +const SCIP_PRESOLTIMING_ALWAYS = (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM) | SCIP_PRESOLTIMING_EXHAUSTIVE +const SCIP_PRESOLTIMING_MAX = ((SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM) | SCIP_PRESOLTIMING_EXHAUSTIVE) | SCIP_PRESOLTIMING_FINAL const SCIP_PROPTIMING_BEFORELP = UInt32(0x0001) const SCIP_PROPTIMING_DURINGLPLOOP = UInt32(0x0002) const SCIP_PROPTIMING_AFTERLPLOOP = UInt32(0x0004) const SCIP_PROPTIMING_AFTERLPNODE = UInt32(0x0008) - -# Skipping MacroDefinition: SCIP_PROPTIMING_ALWAYS ( SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP | SCIP_PROPTIMING_AFTERLPLOOP | SCIP_PROPTIMING_AFTERLPNODE ) typedef - +const SCIP_PROPTIMING_ALWAYS = ((SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP) | SCIP_PROPTIMING_AFTERLPLOOP) | SCIP_PROPTIMING_AFTERLPNODE const SCIP_HEURTIMING_BEFORENODE = UInt32(0x0001) const SCIP_HEURTIMING_DURINGLPLOOP = UInt32(0x0002) const SCIP_HEURTIMING_AFTERLPLOOP = UInt32(0x0004) @@ -227,3710 +979,197 @@ const SCIP_HEURTIMING_DURINGPRICINGLOOP = UInt32(0x0080) const SCIP_HEURTIMING_BEFOREPRESOL = UInt32(0x0100) const SCIP_HEURTIMING_DURINGPRESOLLOOP = UInt32(0x0200) const SCIP_HEURTIMING_AFTERPROPLOOP = UInt32(0x0400) - -# Skipping MacroDefinition: SCIP_HEURTIMING_AFTERNODE ( SCIP_HEURTIMING_AFTERLPNODE | SCIP_HEURTIMING_AFTERPSEUDONODE ) /** call heuristic after the processing of the last node in the current plunge was finished */ -# Skipping MacroDefinition: SCIP_HEURTIMING_AFTERPLUNGE ( SCIP_HEURTIMING_AFTERLPPLUNGE | SCIP_HEURTIMING_AFTERPSEUDOPLUNGE ) typedef - +const SCIP_HEURTIMING_AFTERNODE = SCIP_HEURTIMING_AFTERLPNODE | SCIP_HEURTIMING_AFTERPSEUDONODE +const SCIP_HEURTIMING_AFTERPLUNGE = SCIP_HEURTIMING_AFTERLPPLUNGE | SCIP_HEURTIMING_AFTERPSEUDOPLUNGE const SCIP_PRESOLTIMING = UInt32 const SCIP_PROPTIMING = UInt32 const SCIP_HEURTIMING = UInt32 -# Skipping MacroDefinition: SCIP_DECL_PARAMCHGD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PARAM * param ) # - -# begin enum SCIP_ParamType -const SCIP_ParamType = UInt32 -const SCIP_PARAMTYPE_BOOL = 0 |> UInt32 -const SCIP_PARAMTYPE_INT = 1 |> UInt32 -const SCIP_PARAMTYPE_LONGINT = 2 |> UInt32 -const SCIP_PARAMTYPE_REAL = 3 |> UInt32 -const SCIP_PARAMTYPE_CHAR = 4 |> UInt32 -const SCIP_PARAMTYPE_STRING = 5 |> UInt32 -# end enum SCIP_ParamType - -const SCIP_PARAMTYPE = SCIP_ParamType - -# begin enum SCIP_ParamSetting -const SCIP_ParamSetting = UInt32 -const SCIP_PARAMSETTING_DEFAULT = 0 |> UInt32 -const SCIP_PARAMSETTING_AGGRESSIVE = 1 |> UInt32 -const SCIP_PARAMSETTING_FAST = 2 |> UInt32 -const SCIP_PARAMSETTING_OFF = 3 |> UInt32 -# end enum SCIP_ParamSetting - -const SCIP_PARAMSETTING = SCIP_ParamSetting - -# begin enum SCIP_ParamEmphasis -const SCIP_ParamEmphasis = UInt32 -const SCIP_PARAMEMPHASIS_DEFAULT = 0 |> UInt32 -const SCIP_PARAMEMPHASIS_CPSOLVER = 1 |> UInt32 -const SCIP_PARAMEMPHASIS_EASYCIP = 2 |> UInt32 -const SCIP_PARAMEMPHASIS_FEASIBILITY = 3 |> UInt32 -const SCIP_PARAMEMPHASIS_HARDLP = 4 |> UInt32 -const SCIP_PARAMEMPHASIS_OPTIMALITY = 5 |> UInt32 -const SCIP_PARAMEMPHASIS_COUNTER = 6 |> UInt32 -const SCIP_PARAMEMPHASIS_PHASEFEAS = 7 |> UInt32 -const SCIP_PARAMEMPHASIS_PHASEIMPROVE = 8 |> UInt32 -const SCIP_PARAMEMPHASIS_PHASEPROOF = 9 |> UInt32 -# end enum SCIP_ParamEmphasis - -const SCIP_PARAMEMPHASIS = SCIP_ParamEmphasis - -struct SCIP_Param -end - -const SCIP_PARAM = Cvoid - -struct SCIP_ParamData -end - -const SCIP_PARAMDATA = Cvoid - -struct SCIP_ParamSet -end - -const SCIP_PARAMSET = Cvoid - -# Skipping MacroDefinition: SCIP_EVENTTYPE_DISABLED UINT64_C ( 0x00000000 ) /**< the event was disabled and has no effect any longer */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_VARADDED UINT64_C ( 0x00000001 ) /**< a variable has been added to the transformed problem */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_VARDELETED UINT64_C ( 0x00000002 ) /**< a variable will be deleted from the transformed problem */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_VARFIXED UINT64_C ( 0x00000004 ) /**< a variable has been fixed, aggregated, or multi-aggregated */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_VARUNLOCKED UINT64_C ( 0x00000008 ) /**< the number of rounding locks of a variable was reduced to zero or one */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_OBJCHANGED UINT64_C ( 0x00000010 ) /**< the objective value of a variable has been changed */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_GLBCHANGED UINT64_C ( 0x00000020 ) /**< the global lower bound of a variable has been changed */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_GUBCHANGED UINT64_C ( 0x00000040 ) /**< the global upper bound of a variable has been changed */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_LBTIGHTENED UINT64_C ( 0x00000080 ) /**< the local lower bound of a variable has been increased */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_LBRELAXED UINT64_C ( 0x00000100 ) /**< the local lower bound of a variable has been decreased */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_UBTIGHTENED UINT64_C ( 0x00000200 ) /**< the local upper bound of a variable has been decreased */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_UBRELAXED UINT64_C ( 0x00000400 ) /**< the local upper bound of a variable has been increased */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_GHOLEADDED UINT64_C ( 0x00000800 ) /**< a global hole has been added to the hole list of a variable's domain */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_GHOLEREMOVED UINT64_C ( 0x00001000 ) /**< a global hole has been removed from the hole list of a variable's domain */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_LHOLEADDED UINT64_C ( 0x00002000 ) /**< a local hole has been added to the hole list of a variable's domain */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_LHOLEREMOVED UINT64_C ( 0x00004000 ) /**< a local hole has been removed from the hole list of a variable's domain */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_IMPLADDED UINT64_C ( 0x00008000 ) /**< the variable's implication list, variable bound or clique information was extended */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_PRESOLVEROUND UINT64_C ( 0x00010000 ) /**< a presolving round has been finished */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEFOCUSED UINT64_C ( 0x00020000 ) /**< a node has been focused and is now the focus node */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEFEASIBLE UINT64_C ( 0x00040000 ) /**< the LP/pseudo solution of the node was feasible */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEINFEASIBLE UINT64_C ( 0x00080000 ) /**< the focus node has been proven to be infeasible or was bounded */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEBRANCHED UINT64_C ( 0x00100000 ) /**< the focus node has been solved by branching */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_FIRSTLPSOLVED UINT64_C ( 0x00200000 ) /**< the node's initial LP was solved */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_LPSOLVED UINT64_C ( 0x00400000 ) /**< the node's LP was completely solved with cut & price */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_POORSOLFOUND UINT64_C ( 0x00800000 ) /**< a good enough primal feasible (but not new best) solution was found */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_BESTSOLFOUND UINT64_C ( 0x01000000 ) /**< a new best primal feasible solution was found */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWADDEDSEPA UINT64_C ( 0x02000000 ) /**< a row has been added to SCIP's separation storage */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWDELETEDSEPA UINT64_C ( 0x04000000 ) /**< a row has been removed from SCIP's separation storage */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWADDEDLP UINT64_C ( 0x08000000 ) /**< a row has been added to the LP */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWDELETEDLP UINT64_C ( 0x10000000 ) /**< a row has been removed from the LP */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWCOEFCHANGED UINT64_C ( 0x20000000 ) /**< a coefficient of a row has been changed (row specific event) */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWCONSTCHANGED UINT64_C ( 0x40000000 ) /**< the constant of a row has been changed (row specific event) */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWSIDECHANGED UINT64_C ( 0x80000000 ) /**< a side of a row has been changed (row specific event) */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_SYNC UINT64_C ( 0x100000000 ) /**< synchronization event */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_GBDCHANGED ( SCIP_EVENTTYPE_GLBCHANGED | SCIP_EVENTTYPE_GUBCHANGED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_LBCHANGED ( SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_UBCHANGED ( SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_UBRELAXED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_BOUNDTIGHTENED ( SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_UBTIGHTENED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_BOUNDRELAXED ( SCIP_EVENTTYPE_LBRELAXED | SCIP_EVENTTYPE_UBRELAXED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_BOUNDCHANGED ( SCIP_EVENTTYPE_LBCHANGED | SCIP_EVENTTYPE_UBCHANGED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_GHOLECHANGED ( SCIP_EVENTTYPE_GHOLEADDED | SCIP_EVENTTYPE_GHOLEREMOVED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_LHOLECHANGED ( SCIP_EVENTTYPE_LHOLEADDED | SCIP_EVENTTYPE_LHOLEREMOVED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_HOLECHANGED ( SCIP_EVENTTYPE_GHOLECHANGED | SCIP_EVENTTYPE_LHOLECHANGED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_DOMCHANGED ( SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_HOLECHANGED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_VARCHANGED ( SCIP_EVENTTYPE_VARFIXED | SCIP_EVENTTYPE_VARUNLOCKED | SCIP_EVENTTYPE_OBJCHANGED | SCIP_EVENTTYPE_GBDCHANGED | SCIP_EVENTTYPE_DOMCHANGED | SCIP_EVENTTYPE_IMPLADDED | SCIP_EVENTTYPE_VARDELETED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_VAREVENT ( SCIP_EVENTTYPE_VARADDED | SCIP_EVENTTYPE_VARCHANGED ) /* event masks for node events */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_NODESOLVED ( SCIP_EVENTTYPE_NODEFEASIBLE | SCIP_EVENTTYPE_NODEINFEASIBLE | SCIP_EVENTTYPE_NODEBRANCHED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_NODEEVENT ( SCIP_EVENTTYPE_NODEFOCUSED | SCIP_EVENTTYPE_NODESOLVED ) /* event masks for LP events */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_LPEVENT ( SCIP_EVENTTYPE_FIRSTLPSOLVED | SCIP_EVENTTYPE_LPSOLVED ) /* event masks for primal solution events */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_SOLFOUND ( SCIP_EVENTTYPE_POORSOLFOUND | SCIP_EVENTTYPE_BESTSOLFOUND ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_SOLEVENT ( SCIP_EVENTTYPE_SOLFOUND ) /* event masks for row events */ -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWCHANGED ( SCIP_EVENTTYPE_ROWCOEFCHANGED | SCIP_EVENTTYPE_ROWCONSTCHANGED | SCIP_EVENTTYPE_ROWSIDECHANGED ) # -# Skipping MacroDefinition: SCIP_EVENTTYPE_ROWEVENT ( SCIP_EVENTTYPE_ROWADDEDSEPA | SCIP_EVENTTYPE_ROWDELETEDSEPA | SCIP_EVENTTYPE_ROWADDEDLP | SCIP_EVENTTYPE_ROWDELETEDLP | SCIP_EVENTTYPE_ROWCHANGED ) typedef - -const SCIP_EVENTTYPE_FORMAT = PRIx64 - -# Skipping MacroDefinition: SCIP_DECL_EVENTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** destructor of event handler to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - eventhdlr : the event handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_EVENTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** initialization method of event handler (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - eventhdlr : the event handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_EVENTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** deinitialization method of event handler (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - eventhdlr : the event handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_EVENTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** solving process initialization method of event handler (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The event handler may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - eventhdlr : the event handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_EVENTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** solving process deinitialization method of event handler (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The event handler should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - eventhdlr : the event handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_EVENTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr ) /** frees specific event data -# * -# * input: -# * - scip : SCIP main data structure -# * - eventhdlr : the event handler itself -# * - eventdata : pointer to the event data to free -# */ -# Skipping MacroDefinition: SCIP_DECL_EVENTDELETE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr , SCIP_EVENTDATA * * eventdata ) /** execution method of event handler -# * -# * Processes the event. The method is called every time an event occurs, for which the event handler -# * is responsible. Event handlers may declare themselves responsible for events by calling the -# * corresponding SCIPcatch...() method. This method creates an event filter object to point to the -# * given event handler and event data. -# * -# * input: -# * - scip : SCIP main data structure -# * - eventhdlr : the event handler itself -# * - event : event to process -# * - eventdata : user data for the event -# */ -# Skipping MacroDefinition: SCIP_DECL_EVENTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_EVENTHDLR * eventhdlr , SCIP_EVENT * event , SCIP_EVENTDATA * eventdata ) # - -const SCIP_EVENTTYPE = UInt64 - -struct SCIP_Eventhdlr -end - -const SCIP_EVENTHDLR = Cvoid - -struct SCIP_EventhdlrData -end - -const SCIP_EVENTHDLRDATA = Cvoid - -struct SCIP_Event -end - -const SCIP_EVENT = Cvoid - -struct SCIP_EventVarAdded -end +@cenum(SCIP_NodeType, + SCIP_NODETYPE_FOCUSNODE = 0, + SCIP_NODETYPE_PROBINGNODE = 1, + SCIP_NODETYPE_SIBLING = 2, + SCIP_NODETYPE_CHILD = 3, + SCIP_NODETYPE_LEAF = 4, + SCIP_NODETYPE_DEADEND = 5, + SCIP_NODETYPE_JUNCTION = 6, + SCIP_NODETYPE_PSEUDOFORK = 7, + SCIP_NODETYPE_FORK = 8, + SCIP_NODETYPE_SUBROOT = 9, + SCIP_NODETYPE_REFOCUSNODE = 10, +) -const SCIP_EVENTVARADDED = Cvoid - -struct SCIP_EventVarDeleted -end - -const SCIP_EVENTVARDELETED = Cvoid - -struct SCIP_EventVarFixed -end - -const SCIP_EVENTVARFIXED = Cvoid - -struct SCIP_EventVarUnlocked -end - -const SCIP_EVENTVARUNLOCKED = Cvoid - -struct SCIP_EventObjChg -end - -const SCIP_EVENTOBJCHG = Cvoid - -struct SCIP_EventBdChg -end - -const SCIP_EVENTBDCHG = Cvoid - -struct SCIP_EventHole -end - -const SCIP_EVENTHOLE = Cvoid - -struct SCIP_EventImplAdd -end - -const SCIP_EVENTIMPLADD = Cvoid - -struct SCIP_EventRowAddedSepa -end - -const SCIP_EVENTROWADDEDSEPA = Cvoid - -struct SCIP_EventRowDeletedSepa -end - -const SCIP_EVENTROWDELETEDSEPA = Cvoid - -struct SCIP_EventRowAddedLP -end - -const SCIP_EVENTROWADDEDLP = Cvoid - -struct SCIP_EventRowDeletedLP -end - -const SCIP_EVENTROWDELETEDLP = Cvoid - -struct SCIP_EventRowCoefChanged -end - -const SCIP_EVENTROWCOEFCHANGED = Cvoid - -struct SCIP_EventRowConstChanged -end - -const SCIP_EVENTROWCONSTCHANGED = Cvoid - -struct SCIP_EventRowSideChanged -end - -const SCIP_EVENTROWSIDECHANGED = Cvoid - -struct SCIP_EventData -end - -const SCIP_EVENTDATA = Cvoid - -struct SCIP_EventFilter -end - -const SCIP_EVENTFILTER = Cvoid - -struct SCIP_EventQueue -end - -const SCIP_EVENTQUEUE = Cvoid - -# begin enum SCIP_LPSolStat -const SCIP_LPSolStat = UInt32 -const SCIP_LPSOLSTAT_NOTSOLVED = 0 |> UInt32 -const SCIP_LPSOLSTAT_OPTIMAL = 1 |> UInt32 -const SCIP_LPSOLSTAT_INFEASIBLE = 2 |> UInt32 -const SCIP_LPSOLSTAT_UNBOUNDEDRAY = 3 |> UInt32 -const SCIP_LPSOLSTAT_OBJLIMIT = 4 |> UInt32 -const SCIP_LPSOLSTAT_ITERLIMIT = 5 |> UInt32 -const SCIP_LPSOLSTAT_TIMELIMIT = 6 |> UInt32 -const SCIP_LPSOLSTAT_ERROR = 7 |> UInt32 -# end enum SCIP_LPSolStat - -const SCIP_LPSOLSTAT = SCIP_LPSolStat - -# begin enum SCIP_BoundType -const SCIP_BoundType = UInt32 -const SCIP_BOUNDTYPE_LOWER = 0 |> UInt32 -const SCIP_BOUNDTYPE_UPPER = 1 |> UInt32 -# end enum SCIP_BoundType - -const SCIP_BOUNDTYPE = SCIP_BoundType - -# begin enum SCIP_SideType -const SCIP_SideType = UInt32 -const SCIP_SIDETYPE_LEFT = 0 |> UInt32 -const SCIP_SIDETYPE_RIGHT = 1 |> UInt32 -# end enum SCIP_SideType - -const SCIP_SIDETYPE = SCIP_SideType - -# begin enum SCIP_RowOriginType -const SCIP_RowOriginType = UInt32 -const SCIP_ROWORIGINTYPE_UNSPEC = 0 |> UInt32 -const SCIP_ROWORIGINTYPE_CONS = 1 |> UInt32 -const SCIP_ROWORIGINTYPE_SEPA = 2 |> UInt32 -const SCIP_ROWORIGINTYPE_REOPT = 3 |> UInt32 -# end enum SCIP_RowOriginType - -const SCIP_ROWORIGINTYPE = SCIP_RowOriginType - -# begin enum SCIP_LPAlgo -const SCIP_LPAlgo = UInt32 -const SCIP_LPALGO_PRIMALSIMPLEX = 0 |> UInt32 -const SCIP_LPALGO_DUALSIMPLEX = 1 |> UInt32 -const SCIP_LPALGO_BARRIER = 2 |> UInt32 -const SCIP_LPALGO_BARRIERCROSSOVER = 3 |> UInt32 -# end enum SCIP_LPAlgo - -const SCIP_LPALGO = SCIP_LPAlgo - -struct SCIP_ColSolVals -end - -const SCIP_COLSOLVALS = Cvoid - -struct SCIP_RowSolVals -end - -const SCIP_ROWSOLVALS = Cvoid - -struct SCIP_LpSolVals -end - -const SCIP_LPSOLVALS = Cvoid - -struct SCIP_Col -end - -const SCIP_COL = Cvoid - -struct SCIP_Row -end - -const SCIP_ROW = Cvoid - -struct SCIP_Lp -end - -const SCIP_LP = Cvoid - -struct SCIP_NlRow -end - -const SCIP_NLROW = Cvoid - -struct SCIP_Nlp -end - -const SCIP_NLP = Cvoid +const SCIP_NODETYPE = SCIP_NodeType +const SCIP_Probingnode = Cvoid +const SCIP_PROBINGNODE = SCIP_Probingnode +const SCIP_Sibling = Cvoid +const SCIP_SIBLING = SCIP_Sibling +const SCIP_Child = Cvoid +const SCIP_CHILD = SCIP_Child +const SCIP_Leaf = Cvoid +const SCIP_LEAF = SCIP_Leaf +const SCIP_Junction = Cvoid +const SCIP_JUNCTION = SCIP_Junction +const SCIP_Pseudofork = Cvoid +const SCIP_PSEUDOFORK = SCIP_Pseudofork +const SCIP_Fork = Cvoid +const SCIP_FORK = SCIP_Fork +const SCIP_Subroot = Cvoid +const SCIP_SUBROOT = SCIP_Subroot +const SCIP_Node = Cvoid +const SCIP_NODE = SCIP_Node +const SCIP_PendingBdchg = Cvoid +const SCIP_PENDINGBDCHG = SCIP_PendingBdchg +const SCIP_Tree = Cvoid +const SCIP_TREE = SCIP_Tree const NLOCKTYPES = 2 -# Skipping MacroDefinition: SCIP_DECL_VARDELORIG ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * var , SCIP_VARDATA * * vardata ) /** creates transformed variable for original user variable -# * -# * Because the original variable and the user data of the original variable should not be -# * modified during the solving process, a transformed variable is created as a copy of -# * the original variable. If the user variable data is never modified during the solving -# * process anyways, it is enough to simple copy the user data's pointer. This is the -# * default implementation, which is used when a NULL is given as VARTRANS method. -# * If the user data may be modified during the solving process (e.g. during preprocessing), -# * the VARTRANS method must be given and has to copy the user variable data to a different -# * memory location. -# * -# * input: -# * - scip : SCIP main data structure -# * - sourcevar : original variable -# * - sourcedata : source variable data to transform -# * - targetvar : transformed variable -# * - targetdata : pointer to store created transformed variable data -# */ -# Skipping MacroDefinition: SCIP_DECL_VARTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * sourcevar , SCIP_VARDATA * sourcedata , SCIP_VAR * targetvar , SCIP_VARDATA * * targetdata ) /** frees user data of transformed variable (called when the transformed variable is freed) -# * -# * This method has to be implemented, if the VARTRANS method is not a simple pointer -# * copy operation like in the default VARTRANS implementation. It should free the -# * user data of the transformed variable, that was created in the VARTRANS method. -# * -# * input: -# * - scip : SCIP main data structure -# * - var : transformed variable the data to free is belonging to -# * - vardata : pointer to the user variable data to free -# */ -# Skipping MacroDefinition: SCIP_DECL_VARDELTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * var , SCIP_VARDATA * * vardata ) /** copies variable data of source SCIP variable for the target SCIP variable -# * -# * This method should copy the variable data of the source SCIP and create a target variable data for target -# * variable. This callback is optimal. If the copying process was successful the target variable gets this variable -# * data assigned. In case the result pointer is set to SCIP_DIDNOTRUN the target variable will have no variable data at -# * all. -# * -# * The variable map and the constraint map can be used via the function SCIPgetVarCopy() and SCIPgetConsCopy(), -# * respectively, to get for certain variables and constraints of the source SCIP the counter parts in the target -# * SCIP. You should be very carefully in using these two methods since they could lead to infinity loop. -# * -# * input: -# * - scip : target SCIP data structure -# * - sourcescip : source SCIP main data structure -# * - sourcevar : variable of the source SCIP -# * - sourcedata : variable data of the source variable which should get copied -# * - varmap, : a hashmap which stores the mapping of source variables to corresponding target variables -# * - consmap, : a hashmap which stores the mapping of source constraints to corresponding target constraints -# * - targetvar : variable of the (target) SCIP (targetvar is the copy of sourcevar) -# * - targetdata : pointer to store created copy of the variable data for the (target) SCIP -# * -# * output: -# * - result : pointer to store the result of the call -# * -# * possible return values for *result: -# * - SCIP_DIDNOTRUN : the copying process was not performed -# * - SCIP_SUCCESS : the copying process was successfully performed -# */ -# Skipping MacroDefinition: SCIP_DECL_VARCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP * sourcescip , SCIP_VAR * sourcevar , SCIP_VARDATA * sourcedata , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_VAR * targetvar , SCIP_VARDATA * * targetdata , SCIP_RESULT * result ) # - -# begin enum SCIP_Varstatus -const SCIP_Varstatus = UInt32 -const SCIP_VARSTATUS_ORIGINAL = 0 |> UInt32 -const SCIP_VARSTATUS_LOOSE = 1 |> UInt32 -const SCIP_VARSTATUS_COLUMN = 2 |> UInt32 -const SCIP_VARSTATUS_FIXED = 3 |> UInt32 -const SCIP_VARSTATUS_AGGREGATED = 4 |> UInt32 -const SCIP_VARSTATUS_MULTAGGR = 5 |> UInt32 -const SCIP_VARSTATUS_NEGATED = 6 |> UInt32 -# end enum SCIP_Varstatus +# Skipping MacroDefinition: SCIP_DECL_VARDELORIG ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * var , SCIP_VARDATA * * vardata ) +# Skipping MacroDefinition: SCIP_DECL_VARTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * sourcevar , SCIP_VARDATA * sourcedata , SCIP_VAR * targetvar , SCIP_VARDATA * * targetdata ) +# Skipping MacroDefinition: SCIP_DECL_VARDELTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_VAR * var , SCIP_VARDATA * * vardata ) +# Skipping MacroDefinition: SCIP_DECL_VARCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP * sourcescip , SCIP_VAR * sourcevar , SCIP_VARDATA * sourcedata , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_VAR * targetvar , SCIP_VARDATA * * targetdata , SCIP_RESULT * result ) + +@cenum(SCIP_Varstatus, + SCIP_VARSTATUS_ORIGINAL = 0, + SCIP_VARSTATUS_LOOSE = 1, + SCIP_VARSTATUS_COLUMN = 2, + SCIP_VARSTATUS_FIXED = 3, + SCIP_VARSTATUS_AGGREGATED = 4, + SCIP_VARSTATUS_MULTAGGR = 5, + SCIP_VARSTATUS_NEGATED = 6, +) const SCIP_VARSTATUS = SCIP_Varstatus -# begin enum SCIP_Vartype -const SCIP_Vartype = UInt32 -const SCIP_VARTYPE_BINARY = 0 |> UInt32 -const SCIP_VARTYPE_INTEGER = 1 |> UInt32 -const SCIP_VARTYPE_IMPLINT = 2 |> UInt32 -const SCIP_VARTYPE_CONTINUOUS = 3 |> UInt32 -# end enum SCIP_Vartype +@cenum(SCIP_Vartype, + SCIP_VARTYPE_BINARY = 0, + SCIP_VARTYPE_INTEGER = 1, + SCIP_VARTYPE_IMPLINT = 2, + SCIP_VARTYPE_CONTINUOUS = 3, +) const SCIP_VARTYPE = SCIP_Vartype -# begin enum SCIP_DomchgType -const SCIP_DomchgType = UInt32 -const SCIP_DOMCHGTYPE_DYNAMIC = 0 |> UInt32 -const SCIP_DOMCHGTYPE_BOTH = 1 |> UInt32 -const SCIP_DOMCHGTYPE_BOUND = 2 |> UInt32 -# end enum SCIP_DomchgType +@cenum(SCIP_DomchgType, + SCIP_DOMCHGTYPE_DYNAMIC = 0, + SCIP_DOMCHGTYPE_BOTH = 1, + SCIP_DOMCHGTYPE_BOUND = 2, +) const SCIP_DOMCHGTYPE = SCIP_DomchgType -# begin enum SCIP_BoundchgType -const SCIP_BoundchgType = UInt32 -const SCIP_BOUNDCHGTYPE_BRANCHING = 0 |> UInt32 -const SCIP_BOUNDCHGTYPE_CONSINFER = 1 |> UInt32 -const SCIP_BOUNDCHGTYPE_PROPINFER = 2 |> UInt32 -# end enum SCIP_BoundchgType +@cenum(SCIP_BoundchgType, + SCIP_BOUNDCHGTYPE_BRANCHING = 0, + SCIP_BOUNDCHGTYPE_CONSINFER = 1, + SCIP_BOUNDCHGTYPE_PROPINFER = 2, +) const SCIP_BOUNDCHGTYPE = SCIP_BoundchgType -# begin enum SCIP_LockType -const SCIP_LockType = UInt32 -const SCIP_LOCKTYPE_MODEL = 0 |> UInt32 -const SCIP_LOCKTYPE_CONFLICT = 1 |> UInt32 -# end enum SCIP_LockType +@cenum(SCIP_LockType, + SCIP_LOCKTYPE_MODEL = 0, + SCIP_LOCKTYPE_CONFLICT = 1, +) const SCIP_LOCKTYPE = SCIP_LockType - -struct SCIP_DomChgBound -end - -const SCIP_DOMCHGBOUND = Cvoid - -struct SCIP_DomChgBoth -end - -const SCIP_DOMCHGBOTH = Cvoid - -struct SCIP_DomChgDyn -end - -const SCIP_DOMCHGDYN = Cvoid - -struct SCIP_DomChg - _SCIP_DomChg::Cvoid -end - -const SCIP_DOMCHG = Cvoid - -struct SCIP_BoundChg -end - -const SCIP_BOUNDCHG = Cvoid - -struct SCIP_BdChgIdx -end - -const SCIP_BDCHGIDX = Cvoid - -struct SCIP_BdChgInfo -end - -const SCIP_BDCHGINFO = Cvoid - -struct SCIP_BranchingData -end - -const SCIP_BRANCHINGDATA = Cvoid - -struct SCIP_InferenceData -end - -const SCIP_INFERENCEDATA = Cvoid - -struct SCIP_HoleChg -end - -const SCIP_HOLECHG = Cvoid - -struct SCIP_Hole -end - -const SCIP_HOLE = Cvoid - -struct SCIP_Holelist -end - -const SCIP_HOLELIST = Cvoid - -struct SCIP_Dom -end - -const SCIP_DOM = Cvoid - -struct SCIP_Original -end - -const SCIP_ORIGINAL = Cvoid - -struct SCIP_Aggregate -end - -const SCIP_AGGREGATE = Cvoid - -struct SCIP_Multaggr -end - -const SCIP_MULTAGGR = Cvoid - -struct SCIP_Negate -end - -const SCIP_NEGATE = Cvoid - -struct SCIP_Var -end - -const SCIP_VAR = Cvoid - -struct SCIP_VarData -end - -const SCIP_VARDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_PROBDELORIG ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * * probdata ) /** creates user data of transformed problem by transforming the original user problem data -# * (called after problem was transformed) -# * -# * Because the original problem and the user data of the original problem should not be -# * modified during the solving process, a transformed problem is created as a copy of -# * the original problem. If the user problem data is never modified during the solving -# * process anyways, it is enough to simple copy the user data's pointer. This is the -# * default implementation, which is used when a NULL is given as PROBTRANS method. -# * If the user data may be modified during the solving process (e.g. during preprocessing), -# * the PROBTRANS method must be given and has to copy the user problem data to a different -# * memory location. -# * -# * input: -# * - scip : SCIP main data structure -# * - sourcedata : source problem data to transform -# * - targetdata : pointer to store created transformed problem data -# */ -# Skipping MacroDefinition: SCIP_DECL_PROBTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * sourcedata , SCIP_PROBDATA * * targetdata ) /** frees user data of transformed problem (called when the transformed problem is freed) -# * -# * This method has to be implemented, if the PROBTRANS method is not a simple pointer -# * copy operation like in the default PROBTRANS implementation. It should free the -# * user data of the transformed problem, that was created in the PROBTRANS method. -# * -# * input: -# * - scip : SCIP main data structure -# * - probdata : pointer to the user problem data to free -# */ -# Skipping MacroDefinition: SCIP_DECL_PROBDELTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * * probdata ) /** solving process initialization method of transformed data (called before the branch and bound process begins) -# * -# * This method is called before the branch and bound process begins and can be used to initialize user problem -# * data that depends for example on the number of active problem variables, because these are now fixed. -# * -# * input: -# * - scip : SCIP main data structure -# * - probdata : user problem data -# */ -# Skipping MacroDefinition: SCIP_DECL_PROBINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * probdata ) /** solving process deinitialization method of transformed data (called before the branch and bound data is freed) -# * -# * This method is called before the branch and bound data is freed and should be used to free all data that -# * was allocated in the solving process initialization method. The user has to make sure, that all LP rows associated -# * to the transformed user problem data are released. -# * -# * input: -# * - scip : SCIP main data structure -# * - probdata : user problem data -# * - restart : was this exit solve call triggered by a restart? -# */ -# Skipping MacroDefinition: SCIP_DECL_PROBEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROBDATA * probdata , SCIP_Bool restart ) /** copies user data of source SCIP for the target SCIP -# * -# * This method should copy the problem data of the source SCIP and create a target problem data for (target) -# * SCIP. Implementing this callback is optional. If the copying process was successful the target SCIP gets this -# * problem data assigned. In case the result pointer is set to SCIP_DIDNOTRUN the target SCIP will have no problem data -# * at all. -# * -# * The variable map and the constraint map can be used via the function SCIPgetVarCopy() and SCIPgetConsCopy(), -# * respectively, to get for certain variables and constraints of the source SCIP the counter parts in the target -# * SCIP. You should be very carefully in using these two methods since they could lead to an infinite loop due to -# * recursion. -# * -# * input: -# * - scip : target SCIP data structure -# * - sourcescip : source SCIP main data structure -# * - sourcedata : source user problem data -# * - varmap, : a hashmap which stores the mapping of source variables to corresponding target variables -# * - consmap, : a hashmap which stores the mapping of source constraints to corresponding target constraints -# * - targetdata : pointer to the target user problem data to create -# * - global : create a global or a local copy? -# * -# * output: -# * - result : pointer to store the result of the call -# * -# * possible return values for *result: -# * - SCIP_DIDNOTRUN : the copying process was not performed -# * - SCIP_SUCCESS : the copying process was successfully performed -# */ -# Skipping MacroDefinition: SCIP_DECL_PROBCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP * sourcescip , SCIP_PROBDATA * sourcedata , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_PROBDATA * * targetdata , SCIP_Bool global , SCIP_RESULT * result ) # - -# begin enum SCIP_Objsense -const SCIP_Objsense = Cint -const SCIP_OBJSENSE_MAXIMIZE = -1 |> Int32 -const SCIP_OBJSENSE_MINIMIZE = 1 |> Int32 -# end enum SCIP_Objsense - -const SCIP_OBJSENSE = SCIP_Objsense - -struct SCIP_Prob -end - -const SCIP_PROB = Cvoid - -struct SCIP_ProbData -end - -const SCIP_PROBDATA = Cvoid - -# begin enum SCIP_NodeType -const SCIP_NodeType = UInt32 -const SCIP_NODETYPE_FOCUSNODE = 0 |> UInt32 -const SCIP_NODETYPE_PROBINGNODE = 1 |> UInt32 -const SCIP_NODETYPE_SIBLING = 2 |> UInt32 -const SCIP_NODETYPE_CHILD = 3 |> UInt32 -const SCIP_NODETYPE_LEAF = 4 |> UInt32 -const SCIP_NODETYPE_DEADEND = 5 |> UInt32 -const SCIP_NODETYPE_JUNCTION = 6 |> UInt32 -const SCIP_NODETYPE_PSEUDOFORK = 7 |> UInt32 -const SCIP_NODETYPE_FORK = 8 |> UInt32 -const SCIP_NODETYPE_SUBROOT = 9 |> UInt32 -const SCIP_NODETYPE_REFOCUSNODE = 10 |> UInt32 -# end enum SCIP_NodeType - -const SCIP_NODETYPE = SCIP_NodeType - -struct SCIP_Probingnode -end - -const SCIP_PROBINGNODE = Cvoid - -struct SCIP_Sibling -end - -const SCIP_SIBLING = Cvoid - -struct SCIP_Child -end - -const SCIP_CHILD = Cvoid - -struct SCIP_Leaf -end - -const SCIP_LEAF = Cvoid - -struct SCIP_Junction -end - -const SCIP_JUNCTION = Cvoid - -struct SCIP_Pseudofork -end - -const SCIP_PSEUDOFORK = Cvoid - -struct SCIP_Fork -end - -const SCIP_FORK = Cvoid - -struct SCIP_Subroot -end - -const SCIP_SUBROOT = Cvoid - -struct SCIP_Node -end - -const SCIP_NODE = Cvoid - -struct SCIP_PendingBdchg -end - -const SCIP_PENDINGBDCHG = Cvoid - -struct SCIP_Tree -end - -const SCIP_TREE = Cvoid - -struct Scip -end - -const SCIP = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_BANDITFREE ( x ) SCIP_RETCODE x ( BMS_BLKMEM * blkmem , SCIP_BANDIT * bandit \ -#) /** selection callback for bandit selector */ -# Skipping MacroDefinition: SCIP_DECL_BANDITSELECT ( x ) SCIP_RETCODE x ( SCIP_BANDIT * bandit , int * selection \ -#) /** update callback for bandit algorithms */ -# Skipping MacroDefinition: SCIP_DECL_BANDITUPDATE ( x ) SCIP_RETCODE x ( SCIP_BANDIT * bandit , int selection , SCIP_Real score \ -#) /** reset callback for bandit algorithms */ -# Skipping MacroDefinition: SCIP_DECL_BANDITRESET ( x ) SCIP_RETCODE x ( BMS_BUFMEM * bufmem , SCIP_BANDIT * bandit , SCIP_Real * priorities \ -#) # - -struct SCIP_Bandit -end - -const SCIP_BANDIT = Cvoid - -struct SCIP_BanditVTable -end - -const SCIP_BANDITVTABLE = Cvoid - -struct SCIP_BanditData -end - -const SCIP_BANDITDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_BENDERSCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** destructor of Benders' decomposition to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** initialization method of Benders' decomposition (called after problem was transformed and the Benders' decomposition -# * is active) -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** deinitialization method of Benders' decomposition (called before transformed problem is freed and the Benders' -# * decomposition is active) -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** presolving initialization method of the Benders' decomposition (called when presolving is about to begin) -# * -# * This function is called immediately after the auxiliary variables are created in the master problem. The callback -# * provides the user an opportunity to add variable data to the auxiliary variables. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** presolving deinitialization method of the Benders' decomposition (called after presolving has been finished) -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** solving process initialization method of Benders' decomposition (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The Benders' decomposition may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** solving process deinitialization method of Benders' decomposition (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The Benders' decomposition should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders ) /** the method for creating the Benders' decomposition subproblem. This method is called during the initialisation stage -# * (after the master problem was transformed). -# * -# * @note When the create subproblem callback is invoked, the mapping between the master problem and subproblem -# * variables must be available. The create subproblem callback is invoked immediately after BENDERSINIT. So, it is -# * possible to construct the variable mapping within the BENDERSINIT callback. -# * -# * This method must register the SCIP instance for the subproblem with the Benders' decomposition core by calling -# * SCIPaddBendersSubproblem. Typically, the user must create the SCIP instances for the subproblems. These can be -# * created within a reader or probdata and then registered with the Benders' decomposition core during the call of this -# * callback. If there are any settings required for solving the subproblems, then they should be set here. However, -# * some settings will be overridden by the standard solving method included in the Benders' decomposition framework. -# * If a special solving method is desired, the user can implement the bendersSolvesubXyz callback. -# * -# * If the user defines a subproblem solving method, then in BENDERSCREATESUB, the user must specify whether the -# * subproblem is convex. This is necessary because the dual solutions from convex problems can be used to generate cuts. -# * The classical Benders' optimality and feasibility cuts require that the subproblems are convex. If the subproblem is -# * convex, then the user must call SCIPbendersSetSubproblemIsConvex() -# * -# * If the user does NOT implement a subproblem solving method, then the convexity of the problem is determined -# * internally. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition data structure -# * - probnumber : the subproblem problem number -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSCREATESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , int probnumber ) /** called before the subproblem solving loop for Benders' decomposition. The pre subproblem solve function gives the -# * user an oppportunity to perform any global set up for the Benders' decomposition. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition data structure -# * - sol : the solution that will be checked in the subproblem. Can be NULL. -# * - type : the enforcement type that called the Benders' decomposition solve. -# * - checkint : should the integer subproblems be checked. -# * - skipsolve : flag to return whether the current subproblem solving loop should be skipped -# * - result : a result to be returned to the Benders' constraint handler if the solve is skipped. If the -# * solve is not skipped, then the returned result is ignored. -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_DIDNOTRUN : the subproblem was not solved in this iteration. Other decompositions will be checked. -# * - SCIP_CONSADDED : a constraint has been added to the master problem. No other decompositions will be checked. -# * - SCIP_SEPARATED : a cut has been added to the master problem. No other decompositions will be checked. -# * - SCIP_FEASIBLE : feasibility of the solution is reported to SCIP. Other decompositions will be checked. -# * - SCIP_INFEASIBLE : infeasibility of the solution is reported to SCIP. No other decompositions will be checked. -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSPRESUBSOLVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , SCIP_BENDERSENFOTYPE type , SCIP_Bool checkint , SCIP_Bool * skipsolve , SCIP_RESULT * result ) /** the solving method for a convex Benders' decomposition subproblem. This call back is provided to solve problems -# * for which the dual soluitons are used to generate Benders' decomposition cuts. In the classical Benders' -# * decomposition implementation, this would be an LP. However, it can be any convex problem where the dual solutions -# * are given by a single vector of reals. -# * -# * In the Benders' decomposition subproblem solving process, there are two solving loops. The first is where the convex -# * subproblems, and the convex relaxations of subproblems, are solved. If no cuts are generated after this solving -# * loop, then the second loop solves subproblems defined as CIPs. This callback is executed during the FIRST solving -# * loop only. -# * -# * In the classical Benders' decomposition implementation, if the subproblems are all LPs the only the -# * BENDERSSOLVESUBCONVEX need to be implemented. If the subproblems are MIPs, then it is useful to only implement a -# * single SCIP instance for the subproblem and then change the variable types of the appropriate variables to -# * CONTINUOUS for the CONVEX subproblem solve and to INTEGER for the CIP subproblem solve. -# * -# * The solving methods are separated so that they can be called in parallel. -# * -# * NOTE: The solving methods must be thread safe. -# * -# * This method is called from within the execution method. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition data structure -# * - sol : the solution that will be checked in the subproblem. Can be NULL. -# * - probnumber : the subproblem problem number -# * - onlyconvexcheck : flag to indicate that only the convex relaxations will be checked in this solving loop. This is -# * a feature of the Large Neighbourhood Benders' Search -# * - objective : variable to return the objective function value of the subproblem -# * - result : the result from solving the subproblem -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_DIDNOTRUN : the subproblem was not solved in this iteration -# * - SCIP_FEASIBLE : the subproblem is solved and is feasible -# * - SCIP_INFEASIBLE : the subproblem is solved and is infeasible -# * - SCIP_UNBOUNDED : the subproblem is solved and is unbounded -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSSOLVESUBCONVEX ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , int probnumber , SCIP_Bool onlyconvexcheck , SCIP_Real * objective , SCIP_RESULT * result ) /** the solving method for a Benders' decomposition subproblem as a CIP. This call back is provided to solve problems -# * for which the dual solutions are not well defined. In this case, the cuts are typically generated from the primal -# * solution to the CIP. In the classical Benders' decomposition implementation, this would be a MIP. However, it can -# * be any CIP. -# * -# * In the Benders' decomposition subproblem solving process, there are two solving loops. The first is where the convex -# * subproblems, and the convex relaxations of subproblems, are solved. If no cuts are generated after this solving -# * loop, then the second loop solves subproblems defined as CIPs. This callback is executed during the SECOND solving -# * loop only. -# * -# * The solving methods are separated so that they can be called in parallel. -# * -# * NOTE: The solving methods must be thread safe. -# * -# * This method is called from within the execution method. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition data structure -# * - sol : the solution that will be checked in the subproblem. Can be NULL. -# * - probnumber : the subproblem problem number -# * - objective : variable to return the objective function value of the subproblem -# * - result : the result from solving the subproblem -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_DIDNOTRUN : the subproblem was not solved in this iteration -# * - SCIP_FEASIBLE : the subproblem is solved and is feasible -# * - SCIP_INFEASIBLE : the subproblem is solved and is infeasible -# * - SCIP_UNBOUNDED : the subproblem is solved and is unbounded -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSSOLVESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , int probnumber , SCIP_Real * objective , SCIP_RESULT * result ) /** the post-solve method for Benders' decomposition. The post-solve method is called after the subproblems have -# * been solved but before they have been freed. After the solving of the Benders' decomposition subproblems, the -# * subproblem solving data is freed in the SCIP_DECL_BENDERSFREESUB callback. However, it is not necessary to implement -# * SCIP_DECL_BENDERSFREESUB. -# * -# * If SCIP_DECL_BENDERSFREESUB is not implemented, then the Benders' decomposition framework will perform a default -# * freeing of the subproblems. If a subproblem is an LP, then they will be in probing mode for the subproblem -# * solve. So the freeing process involves ending the probing mode. If the subproblem is a MIP, then the subproblem is -# * solved by calling SCIPsolve. As such, the transformed problem must be freed after each subproblem solve. -# * -# * This callback provides the opportunity for the user to clean up any data structures that should not exist beyond the current -# * iteration. -# * The user has full access to the master and subproblems in this callback. So it is possible to construct solution for -# * the master problem in the method. -# * Additionally, if there are any subproblems that are infeasibility and this can not be resolved, then the it is -# * possible to merge these subproblems into the master problem. The subproblem indices are given in the mergecands -# * array. The merging can be perform by a user defined function or by calling SCIPmergeBendersSubproblemIntoMaster. If a -# * subproblem was merged into the master problem, then the merged flag must be set to TRUE. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition data structure -# * - sol : the solution that was checked by solving the subproblems. Can be NULL. -# * - type : the enforcement type that called the Benders' decomposition solve. -# * - mergecands : the subproblems that are candidates for merging into the master problem, the first -# * npriomergecands are the priority candidates (they should be merged). The remaining -# * (nmergecands - npriomergecands) are subproblems that could be merged if desired. -# * - npriomergecands : the number of priority merge candidates. -# * - nmergecands : the total number of subproblems that are candidates for merging into the master problem -# * - checkint : should the integer subproblems be checked. -# * - infeasible : indicates whether at least one subproblem is infeasible -# * - merged : flag to indicate whether a subproblem was merged into the master problem. -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSPOSTSOLVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_SOL * sol , SCIP_BENDERSENFOTYPE type , int * mergecands , int npriomergecands , int nmergecands , SCIP_Bool checkint , SCIP_Bool infeasible , SCIP_Bool * merged ) /** frees the subproblem so that it can be resolved in the next iteration. As stated above, it is not necessary to -# * implement this callback. If the callback is implemented, the subproblems should be freed by calling -# * SCIPfreeTransform(). However, if the subproblems are LPs, then it could be more efficient to put the subproblem -# * into probing mode prior to solving and then exiting the probing mode during the callback. To put the subproblem into -# * probing mode, the subproblem must be in SCIP_STAGE_SOLVING. This can be achieved by using eventhandlers. -# * -# * If SCIP_DECL_BENDERSFREESUB is not implemented, then the Benders' decomposition framework will perform a default -# * freeing of the subproblems. If a subproblem is an LP, then they will be in probing mode for the subproblem -# * solve. So the freeing process involves ending the probing mode. If the subproblem is a MIP, then the subproblem is -# * solved by calling SCIPsolve. As such, the transformed problem must be freed after each subproblem solve. -# * -# * NOTE: The freeing methods must be thread safe. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition data structure -# * - probnumber : the subproblem problem number -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSFREESUB ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , int probnumber ) /** the variable mapping from the subproblem to the master problem. It is neccessary to have a mapping between every -# * master problem variable and its counterpart in the subproblem. This mapping must go both ways: from master to sub -# * and sub to master. -# * -# * This method is called when generating the cuts. The cuts are generated by using the solution to the subproblem to -# * eliminate a solution to the master problem. -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition structure -# * - var : the variable for which the corresponding variable in the master or subproblem is required -# * - mappedvar : pointer to store the variable that is mapped to var -# * - probnumber : the number of the subproblem that the desired variable belongs to, -1 for the master problem -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSGETVAR ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_VAR * var , SCIP_VAR * * mappedvar , int probnumber ) # - -# begin enum SCIP_BendersEnfoType -const SCIP_BendersEnfoType = UInt32 -const SCIP_BENDERSENFOTYPE_LP = 1 |> UInt32 -const SCIP_BENDERSENFOTYPE_RELAX = 2 |> UInt32 -const SCIP_BENDERSENFOTYPE_PSEUDO = 3 |> UInt32 -const SCIP_BENDERSENFOTYPE_CHECK = 4 |> UInt32 -# end enum SCIP_BendersEnfoType - -const SCIP_BENDERSENFOTYPE = SCIP_BendersEnfoType - -# begin enum SCIP_BendersSolveLoop -const SCIP_BendersSolveLoop = UInt32 -const SCIP_BENDERSSOLVELOOP_CONVEX = 0 |> UInt32 -const SCIP_BENDERSSOLVELOOP_CIP = 1 |> UInt32 -const SCIP_BENDERSSOLVELOOP_USERCONVEX = 2 |> UInt32 -const SCIP_BENDERSSOLVELOOP_USERCIP = 3 |> UInt32 -# end enum SCIP_BendersSolveLoop - -const SCIP_BENDERSSOLVELOOP = SCIP_BendersSolveLoop - -# begin enum SCIP_BendersSubStatus -const SCIP_BendersSubStatus = UInt32 -const SCIP_BENDERSSUBSTATUS_UNKNOWN = 0 |> UInt32 -const SCIP_BENDERSSUBSTATUS_OPTIMAL = 1 |> UInt32 -const SCIP_BENDERSSUBSTATUS_AUXVIOL = 2 |> UInt32 -const SCIP_BENDERSSUBSTATUS_INFEAS = 3 |> UInt32 -# end enum SCIP_BendersSubStatus - -const SCIP_BENDERSSUBSTATUS = SCIP_BendersSubStatus - -struct SCIP_Benders -end - -const SCIP_BENDERS = Cvoid - -struct SCIP_BendersData -end - -const SCIP_BENDERSDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_BENDERSCUT * benderscut ) /** destructor of the Benders' decomposition cut to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - benderscut : the Benders' decomposition cut structure -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** initialization method of the Benders' decomposition cut (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - benderscut : the Benders' decomposition cut structure -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** deinitialization method of the Benders' decomposition cut (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - benderscut : the Benders' decomposition cut structure -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** solving process initialization method of the Benders' decomposition cut (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * -# * input: -# * - scip : SCIP main data structure -# * - benderscut : the Benders' decomposition cut structure -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** solving process deinitialization method of the Benders' decomposition cut (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The Benders' decomposition cut should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - benderscut : the Benders' decomposition cut structure -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERSCUT * benderscut ) /** execution method of the Benders' decomposition cut technique -# * -# * input: -# * - scip : SCIP main data structure -# * - benders : the Benders' decomposition structure -# * - benderscut : the Benders' cut structure -# * - sol : the solution that was used for setting up the subproblems -# * - probnumber : the number of the subproblem from which the cut is generated -# * - type : the enforcement type that called the subproblem solve -# * - result : pointer to store the result of the cut algorithm -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_DIDNOTRUN : if the Benders' cut was not run. -# * - SCIP_DIDNOTFIND : if the Benders' cut was run, but there was an error in generating the cut. -# * - SCIP_FEASIBLE : if the Benders' decomposition cut algorithm has not generated a constraint or cut. -# * - SCIP_CONSADDED : an additional constraint for the Benders' decomposition cut was generated -# * - SCIP_SEPARATED : a cutting plane representing the Benders' decomposition cut was generated -# */ -# Skipping MacroDefinition: SCIP_DECL_BENDERSCUTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BENDERS * benders , SCIP_BENDERSCUT * benderscut , SCIP_SOL * sol , int probnumber , SCIP_BENDERSENFOTYPE type , SCIP_RESULT * result ) # - -struct SCIP_Benderscut -end - -const SCIP_BENDERSCUT = Cvoid - -struct SCIP_BenderscutData -end - -const SCIP_BENDERSCUTDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_BRANCHCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** destructor of branching method to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - branchrule : the branching rule itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BRANCHFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** initialization method of branching rule (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - branchrule : the branching rule itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BRANCHINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** deinitialization method of branching rule (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - branchrule : the branching rule itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BRANCHEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** solving process initialization method of branching rule (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The branching rule may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - branchrule : the branching rule itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BRANCHINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** solving process deinitialization method of branching rule (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The branching rule should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - branchrule : the branching rule itself -# */ -# Skipping MacroDefinition: SCIP_DECL_BRANCHEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule ) /** branching execution method for fractional LP solutions -# * -# * input: -# * - scip : SCIP main data structure -# * - branchrule : the branching rule itself -# * - allowaddcons : is the branching rule allowed to add constraints to the current node in order to cut off the -# * current solution instead of creating a branching? -# * - result : pointer to store the result of the branching call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the current node was detected to be infeasible -# * - SCIP_CONSADDED : an additional constraint (e.g. a conflict constraint) was generated; this result code must not be -# * returned, if allowaddcons is FALSE -# * - SCIP_REDUCEDDOM : a domain was reduced that rendered the current LP solution infeasible -# * - SCIP_SEPARATED : a cutting plane was generated -# * - SCIP_BRANCHED : branching was applied -# * - SCIP_DIDNOTFIND : the branching rule searched, but did not find a branching -# * - SCIP_DIDNOTRUN : the branching rule was skipped -# */ -# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) /** branching execution method for external candidates -# * -# * input: -# * - scip : SCIP main data structure -# * - branchrule : the branching rule itself -# * - allowaddcons : is the branching rule allowed to add constraints to the current node in order to cut off the -# * current solution instead of creating a branching? -# * - result : pointer to store the result of the branching call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the current node was detected to be infeasible -# * - SCIP_CONSADDED : an additional constraint (e.g. a conflict constraint) was generated; this result code must not be -# * returned, if allowaddcons is FALSE -# * - SCIP_REDUCEDDOM : a domain was reduced that rendered the current pseudo solution infeasible -# * - SCIP_BRANCHED : branching was applied -# * - SCIP_DIDNOTFIND : the branching rule searched, but did not find a branching -# * - SCIP_DIDNOTRUN : the branching rule was skipped -# */ -# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECEXT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) /** branching execution method for not completely fixed pseudo solutions -# * -# * input: -# * - scip : SCIP main data structure -# * - branchrule : the branching rule itself -# * - allowaddcons : is the branching rule allowed to add constraints to the current node in order to cut off the -# * current solution instead of creating a branching? -# * - result : pointer to store the result of the branching call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the current node was detected to be infeasible -# * - SCIP_CONSADDED : an additional constraint (e.g. a conflict constraint) was generated; this result code must not be -# * returned, if allowaddcons is FALSE -# * - SCIP_REDUCEDDOM : a domain was reduced that rendered the current pseudo solution infeasible -# * - SCIP_BRANCHED : branching was applied -# * - SCIP_DIDNOTFIND : the branching rule searched, but did not find a branching -# * - SCIP_DIDNOTRUN : the branching rule was skipped -# */ -# Skipping MacroDefinition: SCIP_DECL_BRANCHEXECPS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_BRANCHRULE * branchrule , SCIP_Bool allowaddcons , SCIP_RESULT * result ) # - -struct SCIP_BranchCand -end - -const SCIP_BRANCHCAND = Cvoid - -struct SCIP_Branchrule -end - -const SCIP_BRANCHRULE = Cvoid - -struct SCIP_BranchruleData -end - -const SCIP_BRANCHRULEDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_COMPRCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** destructor of tree compression to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - compr : the compression technique itself -# */ -# Skipping MacroDefinition: SCIP_DECL_COMPRFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** initialization method of tree compression (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - compr : the compression technique itself -# */ -# Skipping MacroDefinition: SCIP_DECL_COMPRINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** deinitialization method of tree compression (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - compr : the compression technique itself -# */ -# Skipping MacroDefinition: SCIP_DECL_COMPREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** solving process initialization method of tree compressionc (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The tree compression may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - compr : the compression technique itself -# */ -# Skipping MacroDefinition: SCIP_DECL_COMPRINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** solving process deinitialization method of tree compression (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The tree compression should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - compr : the compression technique itself -# */ -# Skipping MacroDefinition: SCIP_DECL_COMPREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr ) /** execution method of tree compression technique -# * -# * Try to compress the current search tree. The method is called in the node processing loop. -# * -# * input: -# * - scip : SCIP main data structure -# * - compr : the compression technique itself -# * - result : pointer to store the result of the heuristic call -# * -# * possible return values for *result: -# * - SCIP_SUCCESS : the tree could be compressed -# * - SCIP_DIDNITFIND : the method could not compress the tree -# * - SCIP_DIDNOTRUN : the compression was skipped -# */ -# Skipping MacroDefinition: SCIP_DECL_COMPREXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_COMPR * compr , SCIP_RESULT * result ) # - -struct SCIP_Compr -end - -const SCIP_COMPR = Cvoid - -struct SCIP_ComprData -end - -const SCIP_COMPRDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERCREATEINST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONCSOLVERTYPE * concsolvertype , SCIP_CONCSOLVER * concsolver ) /** destroys a concurrent solver instance -# * -# * input: -# * - scip : SCIP main data structure -# * - concsolverinstance : concurrent solver instance to destroy -# * -# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code -# */ -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERDESTROYINST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONCSOLVER * concsolver ) /** frees data of a concurrent solver type -# * -# * input: -# * - scip : SCIP main data structure -# * - data : concurrent solver type data to free -# * -# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code -# */ -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERTYPEFREEDATA ( x ) void x ( SCIP_CONCSOLVERTYPEDATA * * data ) /** initialize random seeds of a concurrent solver -# * -# * input: -# * - concsolver : concurrent solver data structure -# * - seed : seed for initializing the solver's internal random seeds -# * -# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code -# */ -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERINITSEEDS ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , unsigned int seed ) /** synchronization method of concurrent solver for writing data -# * -# * Syncronizes with other solvers. The concurrent solver should pass new solutions -# * and bounds to the syncstore. For the solutions, no more than maxcandsols of the best solution -# * should be considered for sharing. Additionally a maximum if maxsharedsols should be -# * passed to the syncstore. -# * -# * input: -# * - concsolver : concurrent solver data structure -# * - spi : pointer to the SCIP parallel interface -# * - syncdata : concurrent solver data structure -# * - maxcandsols : how many of the best solutions should be considered for sharing -# * - maxsharedsols : the maximum number of solutions that should be shared -# * -# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code -# */ -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSYNCWRITE ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_SYNCSTORE * syncstore , SCIP_SYNCDATA * syncdata , int maxcandsols , int maxsharedsols , int * nsolsshared ) /** synchronization method of concurrent solver for reading data -# * -# * the concurrent solver should read the solutions and bounds stored in the -# * given synchronization data -# * -# * input: -# * - concsolver : concurrent solver data structure -# * - spi : pointer to the SCIP parallel interface -# * - syncdata : concurrent solver data structure -# * -# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code -# */ -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSYNCREAD ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_SYNCSTORE * syncstore , SCIP_SYNCDATA * syncdata , int * nsolsrecvd , int * ntighterbnds , int * ntighterintbnds ) /** execution method of concurrent solver -# * -# * start solving of the problem given during initialization -# * -# * input: -# * - concsolver : concurrent solver data structure -# * -# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code -# */ -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVEREXEC ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP_Real * solvingtime , SCIP_Longint * nlpiterations , SCIP_Longint * nnodes ) /** stop the solving as soon as possible -# * -# * input: -# * - concsolver : concurrent solver data structure -# * -# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code -# */ -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERSTOP ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver ) /** extract the solving data from the concurrent solver and store it into the SCIP datastructure, -# * so that this SCIP instance has the optimal solution and reports the correct status and statistics. -# * -# * input: -# * - concsolver : concurrent solver data structure -# * - scip : SCIP datastructure -# * -# * returns SCIP_OKAY if everything worked, otherwise, a suitable error code -# */ -# Skipping MacroDefinition: SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA ( x ) SCIP_RETCODE x ( SCIP_CONCSOLVER * concsolver , SCIP * scip ) # - -struct SCIP_ConcSolverType -end - -const SCIP_CONCSOLVERTYPE = Cvoid - -struct SCIP_ConcSolverTypeData -end - -const SCIP_CONCSOLVERTYPEDATA = Cvoid - -struct SCIP_ConcSolver -end - -const SCIP_CONCSOLVER = Cvoid - -struct SCIP_ConcSolverData -end - -const SCIP_CONCSOLVERDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_CONFLICTCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** destructor of conflict handler to free conflict handler data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - conflicthdlr : the conflict handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_CONFLICTFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** initialization method of conflict handler (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - conflicthdlr : the conflict handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_CONFLICTINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** deinitialization method of conflict handler (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - conflicthdlr : the conflict handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** solving process initialization method of conflict handler (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The conflict handler may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - conflicthdlr : the conflict handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_CONFLICTINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** solving process deinitialization method of conflict handler (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The conflict handler should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - conflicthdlr : the conflict handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr ) /** conflict processing method of conflict handler (called when conflict was found) -# * -# * This method is called, when the conflict analysis found a conflict on variable bounds. -# * The conflict handler may update its data accordingly and create a constraint out of the conflict set. -# * If the parameter "resolved" is set, the conflict handler should not create a constraint, because -# * a different conflict handler with higher priority already created a constraint. -# * The bounds in the conflict set lead to a conflict (i.e. an infeasibility) when all enforced at the same time. -# * Thus, a feasible conflict constraint must demand that at least one of the variables in the conflict -# * set violates its corresponding bound, i.e., fulfills the negation of the bound change in the conflict set. -# * For continuous variables, the negation has to be defined in a relaxed way: if, e.g., the bound in the conflict -# * set is "x <= u", the negation to be used has to be "x >= u", and not "x > u". -# * The given "bdchginfos" array representing the conflict set is only a reference to an internal -# * buffer, that may be modified at any time by SCIP. The user must copy the needed information from the -# * "bdchginfos" array to own data structures, if (s)he wants to use the information later. -# * (S)he should not keep a pointer to the array or pointers to the single bdchginfos in the array, because these -# * may get invalid afterwards. -# * -# * input: -# * - scip : SCIP main data structure -# * - conflicthdlr : the conflict handler itself -# * - node : node to add resulting conflict constraint to (with SCIPaddConsNode()) -# * - validnode : node at which the conflict constraint is valid (should be passed to SCIPaddConsNode()) -# * - bdchginfos : array with bound changes that lead to a conflict -# * - relaxedbds : array with relaxed bounds which are efficient to create a valid conflict -# * - nbdchginfos : number of bound changes in the conflict set -# * -.primalbound : the current primal bound, or -infininity if the conflict arises from an infeasible LP -# * - separate : should the conflict constraint be separated? -# * - local : is the conflict set only valid locally, i.e., should the constraint be created as local constraint? -# * - dynamic : should the conflict constraint be made subject to aging? -# * - removable : should the conflict's relaxation be made subject to LP aging and cleanup? -# * - resolved : is the conflict set already used to create a constraint? -# * - result : pointer to store the result of the conflict processing call -# * -# * possible return values for *result: -# * - SCIP_CONSADDED : the conflict handler created a constraint out of the conflict set -# * - SCIP_DIDNOTFIND : the conflict handler could not create a constraint out of the conflict set -# * - SCIP_DIDNOTRUN : the conflict handler was skipped -# */ -# Skipping MacroDefinition: SCIP_DECL_CONFLICTEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONFLICTHDLR * conflicthdlr , SCIP_NODE * node , SCIP_NODE * validnode , SCIP_BDCHGINFO * * bdchginfos , SCIP_Real * relaxedbds , int nbdchginfos , SCIP_CONFTYPE conftype , SCIP_Bool cutoffinvolved , SCIP_Bool separate , SCIP_Bool local , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool resolved , SCIP_RESULT * result ) # - -struct SCIP_Conflicthdlr -end - -const SCIP_CONFLICTHDLR = Cvoid - -struct SCIP_ConflicthdlrData -end - -const SCIP_CONFLICTHDLRDATA = Cvoid - -struct SCIP_ConflictSet -end - -const SCIP_CONFLICTSET = Cvoid - -struct SCIP_ProofSet -end - -const SCIP_PROOFSET = Cvoid - -struct SCIP_LPBdChgs -end - -const SCIP_LPBDCHGS = Cvoid - -struct SCIP_Conflict -end - -const SCIP_CONFLICT = Cvoid - -# begin enum SCIP_ConflictType -const SCIP_ConflictType = UInt32 -const SCIP_CONFTYPE_UNKNOWN = 0 |> UInt32 -const SCIP_CONFTYPE_PROPAGATION = 1 |> UInt32 -const SCIP_CONFTYPE_INFEASLP = 2 |> UInt32 -const SCIP_CONFTYPE_BNDEXCEEDING = 3 |> UInt32 -const SCIP_CONFTYPE_ALTINFPROOF = 4 |> UInt32 -const SCIP_CONFTYPE_ALTBNDPROOF = 5 |> UInt32 -# end enum SCIP_ConflictType - -const SCIP_CONFTYPE = SCIP_ConflictType - -# begin enum SCIP_ConflictPresolStrat -const SCIP_ConflictPresolStrat = UInt32 -const SCIP_CONFPRES_DISABLED = 0 |> UInt32 -const SCIP_CONFPRES_ONLYLOCAL = 1 |> UInt32 -const SCIP_CONFPRES_ONLYGLOBAL = 2 |> UInt32 -const SCIP_CONFPRES_BOTH = 3 |> UInt32 -# end enum SCIP_ConflictPresolStrat - -const SCIP_CONFPRES = SCIP_ConflictPresolStrat - -# Skipping MacroDefinition: SCIP_NLINCONSTYPES ( ( int ) SCIP_LINCONSTYPE_GENERAL + 1 ) /** copy method for constraint handler plugins (called when SCIP copies plugins) -# * -# * If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, this pointer has to be set to -# * FALSE. If all problem defining objects (constraint handlers and variable pricers) return valid = TRUE for all -# * their copying calls, SCIP assumes that it is an overall one to one copy of the original instance. In this case any -# * reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is -# * set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - valid : was the copying process valid? -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSHDLRCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_Bool * valid ) /** destructor of constraint handler to free constraint handler data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr ) /** initialization method of constraint handler (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints in transformed problem -# * - nconss : number of constraints in transformed problem -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** deinitialization method of constraint handler (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints in transformed problem -# * - nconss : number of constraints in transformed problem -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** presolving initialization method of constraint handler (called when presolving is about to begin) -# * -# * This method is called when the presolving process is about to begin, even if presolving is turned off. -# * The constraint handler may use this call to initialize its data structures. -# * -# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the -# * presolving deinitialization call (SCIP_DECL_CONSEXITPRE()). -# * -# * @note Note that the constraint array might contain constraints that were created but not added to the problem. -# * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem -# * reductions. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints in transformed problem -# * - nconss : number of constraints in transformed problem -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** presolving deinitialization method of constraint handler (called after presolving has been finished) -# * -# * This method is called after the presolving has been finished, even if presolving is turned off. -# * The constraint handler may use this call e.g. to clean up or modify its data structures. -# * -# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the -# * presolving initialization call (SCIP_DECL_CONSINITPRE()). -# * -# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the -# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, -# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. -# * -# * @note Note that the constraint array might contain constraints that were created but not added to the problem. -# * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem -# * reductions. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : final array of constraints in transformed problem -# * - nconss : final number of constraints in transformed problem -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** solving process initialization method of constraint handler (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The constraint handler may use this call to initialize its branch and bound specific data. -# * -# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the -# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, -# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. -# * -# * @note Note that the constraint array might contain constraints that were created but not added to the problem. -# * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem -# * reductions. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints of the constraint handler -# * - nconss : number of constraints of the constraint handler -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** solving process deinitialization method of constraint handler (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The constraint handler should use this call to clean up its branch and bound data, in particular to release -# * all LP rows that he has created or captured. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints of the constraint handler -# * - nconss : number of constraints of the constraint handler -# * - restart : was this exit solve call triggered by a restart? -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_Bool restart ) /** frees specific constraint data -# * -# * @warning There may exist unprocessed events. For example, a variable's bound may have been already changed, but the -# * corresponding bound change event was not yet processed. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint belonging to the constraint data -# * - consdata : pointer to the constraint data to free -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSDELETE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_CONSDATA * * consdata ) /** transforms constraint data into data belonging to the transformed problem -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - sourcecons : source constraint to transform -# * - targetcons : pointer to store created target constraint -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSTRANS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * sourcecons , SCIP_CONS * * targetcons ) /** LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved) -# * -# * Puts the LP relaxations of all "initial" constraints into the LP. The method should put a canonic LP relaxation -# * of all given constraints to the LP with calls to SCIPaddRow(). -# * -# * @warning It is not guaranteed that the problem is going to be declared infeasible if the infeasible pointer is set -# * to TRUE. Therefore, it is recommended that users do not end this method prematurely when an infeasiblity -# * is detected. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * -# * output: -# * - infeasible : pointer to store whether an infeasibility was detected while building the LP -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSINITLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_Bool * infeasible ) /** separation method of constraint handler for LP solution -# * -# * Separates all constraints of the constraint handler. The method is called in the LP solution loop, -# * which means that a valid LP solution exists. -# * -# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation -# * method should process only the useful constraints in most runs, and only occasionally the remaining -# * nconss - nusefulconss constraints. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * - nusefulconss : number of useful (non-obsolete) constraints to process -# * - result : pointer to store the result of the separation call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_CONSADDED : an additional constraint was generated -# * - SCIP_REDUCEDDOM : a variable's domain was reduced -# * - SCIP_SEPARATED : a cutting plane was generated -# * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start -# * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints -# * - SCIP_DIDNOTRUN : the separator was skipped -# * - SCIP_DELAYED : the separator was skipped, but should be called again -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSSEPALP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_RESULT * result ) /** separation method of constraint handler for arbitrary primal solution -# * -# * Separates all constraints of the constraint handler. The method is called outside the LP solution loop (e.g., by -# * a relaxator or a primal heuristic), which means that there is no valid LP solution. -# * Instead, the method should produce cuts that separate the given solution. -# * -# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation -# * method should process only the useful constraints in most runs, and only occasionally the remaining -# * nconss - nusefulconss constraints. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * - nusefulconss : number of useful (non-obsolete) constraints to process -# * - sol : primal solution that should be separated -# * - result : pointer to store the result of the separation call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_CONSADDED : an additional constraint was generated -# * - SCIP_REDUCEDDOM : a variable's domain was reduced -# * - SCIP_SEPARATED : a cutting plane was generated -# * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start -# * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints -# * - SCIP_DIDNOTRUN : the separator was skipped -# * - SCIP_DELAYED : the separator was skipped, but should be called again -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSSEPASOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_SOL * sol , SCIP_RESULT * result ) /** constraint enforcing method of constraint handler for LP solutions -# * -# * The method is called at the end of the node processing loop for a node where the LP was solved. -# * The LP solution has to be checked for feasibility. If possible, an infeasibility should be resolved by -# * branching, reducing a variable's domain to exclude the solution or separating the solution with a valid -# * cutting plane. -# * -# * The enforcing methods of the active constraint handlers are called in decreasing order of their enforcing -# * priorities until the first constraint handler returned with the value SCIP_CUTOFF, SCIP_SEPARATED, -# * SCIP_REDUCEDDOM, SCIP_CONSADDED, or SCIP_BRANCHED. -# * The integrality constraint handler has an enforcing priority of zero. A constraint handler which can -# * (or wants) to enforce its constraints only for integral solutions should have a negative enforcing priority -# * (e.g. the alldiff-constraint can only operate on integral solutions). -# * A constraint handler which wants to incorporate its own branching strategy even on non-integral -# * solutions must have an enforcing priority greater than zero (e.g. the SOS-constraint incorporates -# * SOS-branching on non-integral solutions). -# * -# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing -# * method should process the useful constraints first. The other nconss - nusefulconss constraints should only -# * be enforced, if no violation was found in the useful constraints. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * - nusefulconss : number of useful (non-obsolete) constraints to process -# * - solinfeasible : was the solution already declared infeasible by a constraint handler? -# * - result : pointer to store the result of the enforcing call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_CONSADDED : an additional constraint was generated -# * - SCIP_REDUCEDDOM : a variable's domain was reduced -# * - SCIP_SEPARATED : a cutting plane was generated -# * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility -# * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved -# * - SCIP_FEASIBLE : all constraints of the handler are feasible -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSENFOLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_RESULT * result ) /** constraint enforcing method of constraint handler for relaxation solutions -# * -# * input: -# * - scip : SCIP main data structure -# * - sol : relaxation solution -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * - nusefulconss : number of useful (non-obsolete) constraints to process -# * - solinfeasible : was the solution already declared infeasible by a constraint handler? -# * - result : pointer to store the result of the enforcing call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_CONSADDED : an additional constraint was generated -# * - SCIP_REDUCEDDOM : a variable's domain was reduced -# * - SCIP_SEPARATED : a cutting plane was generated -# * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility -# * - SCIP_SOLVELP : at least one constraint is infeasible, and this can only be resolved by solving the LP -# * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved -# * - SCIP_FEASIBLE : all constraints of the handler are feasible -# * - SCIP_DIDNOTRUN : the enforcement was skipped (only possible, if objinfeasible is true) -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSENFORELAX ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SOL * sol , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_RESULT * result ) /** constraint enforcing method of constraint handler for pseudo solutions -# * -# * The method is called at the end of the node processing loop for a node where the LP was not solved. -# * The pseudo solution has to be checked for feasibility. If possible, an infeasibility should be resolved by -# * branching, reducing a variable's domain to exclude the solution or adding an additional constraint. -# * Separation is not possible, since the LP is not processed at the current node. All LP informations like -# * LP solution, slack values, or reduced costs are invalid and must not be accessed. -# * -# * Like in the enforcing method for LP solutions, the enforcing methods of the active constraint handlers are -# * called in decreasing order of their enforcing priorities until the first constraint handler returned with -# * the value SCIP_CUTOFF, SCIP_REDUCEDDOM, SCIP_CONSADDED, SCIP_BRANCHED, or SCIP_SOLVELP. -# * -# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing -# * method should process the useful constraints first. The other nconss - nusefulconss constraints should only -# * be enforced, if no violation was found in the useful constraints. -# * -# * If the pseudo solution's objective value is lower than the lower bound of the node, it cannot be feasible -# * and the enforcing method may skip it's check and set *result to SCIP_DIDNOTRUN. However, it can also process -# * its constraints and return any other possible result code. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * - nusefulconss : number of useful (non-obsolete) constraints to process -# * - solinfeasible : was the solution already declared infeasible by a constraint handler? -# * - objinfeasible : is the solution infeasible anyway due to violating lower objective bound? -# * - result : pointer to store the result of the enforcing call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_CONSADDED : an additional constraint was generated -# * - SCIP_REDUCEDDOM : a variable's domain was reduced -# * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility -# * - SCIP_SOLVELP : at least one constraint is infeasible, and this can only be resolved by solving the LP -# * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved -# * - SCIP_FEASIBLE : all constraints of the handler are feasible -# * - SCIP_DIDNOTRUN : the enforcement was skipped (only possible, if objinfeasible is true) -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSENFOPS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , SCIP_Bool solinfeasible , SCIP_Bool objinfeasible , SCIP_RESULT * result ) /** feasibility check method of constraint handler for integral solutions -# * -# * The given solution has to be checked for feasibility. -# * -# * The check methods of the active constraint handlers are called in decreasing order of their check -# * priorities until the first constraint handler returned with the result SCIP_INFEASIBLE. -# * The integrality constraint handler has a check priority of zero. A constraint handler which can -# * (or wants) to check its constraints only for integral solutions should have a negative check priority -# * (e.g. the alldiff-constraint can only operate on integral solutions). -# * A constraint handler which wants to check feasibility even on non-integral solutions must have a -# * check priority greater than zero (e.g. if the check is much faster than testing all variables for -# * integrality). -# * -# * In some cases, integrality conditions or rows of the current LP don't have to be checked, because their -# * feasibility is already checked or implicitly given. In these cases, 'checkintegrality' or -# * 'checklprows' is FALSE. -# * -# * If the solution is not NULL, SCIP should also be informed about the constraint violation with a call to -# * SCIPupdateSolConsViolation() and additionally SCIPupdateSolLPRowViolation() for every row of the constraint's current -# * representation in the LP relaxation, if any such rows exist. -# * As a convenience method, SCIPupdateSolLPConsViolation() can be used if the constraint -# * is represented completely by a set of LP rows, meaning that the current constraint violation is equal to the maximum -# * of the contraint violations of the corresponding LP rows. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * - sol : the solution to check feasibility for -# * - checkintegrality: Has integrality to be checked? -# * - checklprows : Do constraints represented by rows in the current LP have to be checked? -# * - printreason : Should the reason for the violation be printed? -# * - completely : Should all violations be checked? -# * - result : pointer to store the result of the feasibility checking call -# * -# * possible return values for *result: -# * - SCIP_INFEASIBLE : at least one constraint of the handler is infeasible -# * - SCIP_FEASIBLE : all constraints of the handler are feasible -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSCHECK ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , SCIP_SOL * sol , SCIP_Bool checkintegrality , SCIP_Bool checklprows , SCIP_Bool printreason , SCIP_Bool completely , SCIP_RESULT * result ) /** domain propagation method of constraint handler -# * -# * The first nusefulconss constraints are the ones, that are identified to likely be violated. The propagation -# * method should process only the useful constraints in most runs, and only occasionally the remaining -# * nconss - nusefulconss constraints. -# * -# * @note if the constraint handler uses dual information in propagation it is nesassary to check via calling -# * SCIPallowDualReds and SCIPallowObjProp if dual reductions and propgation with the current cutoff bound, resp., -# * are allowed. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * - nusefulconss : number of useful (non-obsolete) constraints to process -# * - nmarkedconss : number of constraints which are marked to be definitely propagated -# * - proptiming : current point in the node solving loop -# * - result : pointer to store the result of the propagation call -# * -# * possible return values for *result: -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_REDUCEDDOM : at least one domain reduction was found -# * - SCIP_DIDNOTFIND : the propagator searched but did not find any domain reductions -# * - SCIP_DIDNOTRUN : the propagator was skipped -# * - SCIP_DELAYED : the propagator was skipped, but should be called again -# * - SCIP_DELAYNODE : the current node should be postponed (return value only valid for BEFORELP propagation) -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nusefulconss , int nmarkedconss , SCIP_PROPTIMING proptiming , SCIP_RESULT * result ) /** presolving method of constraint handler -# * -# * The presolver should go through the variables and constraints and tighten the domains or -# * constraints. Each tightening should increase the given total number of changes. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints to process -# * - nconss : number of constraints to process -# * - nrounds : number of presolving rounds already done -# * - presoltiming : current presolving timing -# * - nnewfixedvars : number of variables fixed since the last call to the presolving method -# * - nnewaggrvars : number of variables aggregated since the last call to the presolving method -# * - nnewchgvartypes : number of variable type changes since the last call to the presolving method -# * - nnewchgbds : number of variable bounds tightened since the last call to the presolving method -# * - nnewholes : number of domain holes added since the last call to the presolving method -# * - nnewdelconss : number of deleted constraints since the last call to the presolving method -# * - nnewaddconss : number of added constraints since the last call to the presolving method -# * - nnewupgdconss : number of upgraded constraints since the last call to the presolving method -# * - nnewchgcoefs : number of changed coefficients since the last call to the presolving method -# * - nnewchgsides : number of changed left or right hand sides since the last call to the presolving method -# * -# * @note the counters state the changes since the last call including the changes of this presolving method during its -# * call -# * -# * @note if the constraint handler performs dual presolving it is nesassary to check via calling SCIPallowDualReds -# * if dual reductions are allowed. -# * -# * input/output: -# * - nfixedvars : pointer to count total number of variables fixed of all presolvers -# * - naggrvars : pointer to count total number of variables aggregated of all presolvers -# * - nchgvartypes : pointer to count total number of variable type changes of all presolvers -# * - nchgbds : pointer to count total number of variable bounds tightened of all presolvers -# * - naddholes : pointer to count total number of domain holes added of all presolvers -# * - ndelconss : pointer to count total number of deleted constraints of all presolvers -# * - naddconss : pointer to count total number of added constraints of all presolvers -# * - nupgdconss : pointer to count total number of upgraded constraints of all presolvers -# * - nchgcoefs : pointer to count total number of changed coefficients of all presolvers -# * - nchgsides : pointer to count total number of changed left/right hand sides of all presolvers -# * -# * output: -# * - result : pointer to store the result of the presolving call -# * -# * possible return values for *result: -# * - SCIP_UNBOUNDED : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded -# * - SCIP_CUTOFF : at least one constraint is infeasible in the variable's bounds -> problem is infeasible -# * - SCIP_SUCCESS : the presolving method found a reduction -# * - SCIP_DIDNOTFIND : the presolving method searched, but did not find a presolving change -# * - SCIP_DIDNOTRUN : the presolving method was skipped -# * - SCIP_DELAYED : the presolving method was skipped, but should be called again -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSPRESOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) /** propagation conflict resolving method of constraint handler -# * -# * This method is called during conflict analysis. If the constraint handler wants to support conflict analysis, -# * it should call SCIPinferVarLbCons() or SCIPinferVarUbCons() in domain propagation instead of SCIPchgVarLb() or -# * SCIPchgVarUb() in order to deduce bound changes on variables. -# * In the SCIPinferVarLbCons() and SCIPinferVarUbCons() calls, the handler provides the constraint, that deduced the -# * variable's bound change, and an integer value "inferinfo" that can be arbitrarily chosen. -# * The propagation conflict resolving method can then be implemented, to provide a "reason" for the bound -# * changes, i.e., the bounds of variables at the time of the propagation, that forced the constraint to set the -# * conflict variable's bound to its current value. It can use the "inferinfo" tag to identify its own propagation -# * rule and thus identify the "reason" bounds. The bounds that form the reason of the assignment must then be provided -# * by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), -# * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and/or SCIPaddConflictBinvar() in the propagation conflict -# * resolving method. -# * -# * For example, the logicor constraint c = "x or y or z" fixes variable z to TRUE (i.e. changes the lower bound of z -# * to 1.0), if both, x and y, are assigned to FALSE (i.e. if the upper bounds of these variables are 0.0). It uses -# * SCIPinferVarLbCons(scip, z, 1.0, c, 0) to apply this assignment (an inference information tag is not needed by the -# * constraint handler and is set to 0). -# * In the conflict analysis, the constraint handler may be asked to resolve the lower bound change on z with -# * constraint c, that was applied at a time given by a bound change index "bdchgidx". -# * With a call to SCIPgetVarLbAtIndex(scip, z, bdchgidx, TRUE), the handler can find out, that the lower bound of -# * variable z was set to 1.0 at the given point of time, and should call SCIPaddConflictUb(scip, x, bdchgidx) and -# * SCIPaddConflictUb(scip, y, bdchgidx) to tell SCIP, that the upper bounds of x and y at this point of time were -# * the reason for the deduction of the lower bound of z. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint that deduced the bound change of the conflict variable -# * - infervar : the conflict variable whose bound change has to be resolved -# * - inferinfo : the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call -# * - boundtype : the type of the changed bound (lower or upper bound) -# * - bdchgidx : the index of the bound change, representing the point of time where the change took place -# * - relaxedbd : the relaxed bound which is sufficient to be explained -# * -# * output: -# * - result : pointer to store the result of the propagation conflict resolving call -# * -# * possible return values for *result: -# * - SCIP_SUCCESS : the conflicting bound change has been successfully resolved by adding all reason bounds -# * - SCIP_DIDNOTFIND : the conflicting bound change could not be resolved and has to be put into the conflict set -# * -# * @note it is sufficient to explain/resolve the relaxed bound -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSRESPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_VAR * infervar , int inferinfo , SCIP_BOUNDTYPE boundtype , SCIP_BDCHGIDX * bdchgidx , SCIP_Real relaxedbd , SCIP_RESULT * result ) /** variable rounding lock method of constraint handler -# * -# * This method is called, after a constraint is added or removed from the transformed problem. -# * It should update the rounding locks of the given type of all associated variables with calls to -# * SCIPaddVarLocksType(), depending on the way, the variable is involved in the constraint: -# * - If the constraint may get violated by decreasing the value of a variable, it should call -# * SCIPaddVarLocksType(scip, var, locktype, nlockspos, nlocksneg), saying that rounding down is -# * potentially rendering the (positive) constraint infeasible and rounding up is potentially rendering the -# * negation of the constraint infeasible. -# * - If the constraint may get violated by increasing the value of a variable, it should call -# * SCIPaddVarLocksType(scip, var, locktype, nlocksneg, nlockspos), saying that rounding up is -# * potentially rendering the constraint's negation infeasible and rounding up is potentially rendering the -# * constraint itself infeasible. -# * - If the constraint may get violated by changing the variable in any direction, it should call -# * SCIPaddVarLocksType(scip, var, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg). -# * -# * Consider the linear constraint "3x -5y +2z <= 7" as an example. The variable rounding lock method of the -# * linear constraint handler should call SCIPaddVarLocksType(scip, x, locktype, nlocksneg, nlockspos), -# * SCIPaddVarLocksType(scip, y, locktype, nlockspos, nlocksneg) and -# * SCIPaddVarLocksType(scip, z, type, nlocksneg, nlockspos) to tell SCIP, that rounding up of x and z and rounding -# * down of y can destroy the feasibility of the constraint, while rounding down of x and z and rounding up of y can -# * destroy the feasibility of the constraint's negation "3x -5y +2z > 7". -# * A linear constraint "2 <= 3x -5y +2z <= 7" should call -# * SCIPaddVarLocksType(scip, ..., nlockspos + nlocksneg, nlockspos + nlocksneg) on all variables, since rounding in both -# * directions of each variable can destroy both the feasibility of the constraint and it's negation -# * "3x -5y +2z < 2 or 3x -5y +2z > 7". -# * -# * If the constraint itself contains other constraints as sub constraints (e.g. the "or" constraint concatenation -# * "c(x) or d(x)"), the rounding lock methods of these constraints should be called in a proper way. -# * - If the constraint may get violated by the violation of the sub constraint c, it should call -# * SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg), saying that infeasibility of c may lead to -# * infeasibility of the (positive) constraint, and infeasibility of c's negation (i.e. feasibility of c) may lead -# * to infeasibility of the constraint's negation (i.e. feasibility of the constraint). -# * - If the constraint may get violated by the feasibility of the sub constraint c, it should call -# * SCIPaddConsLocksType(scip, c, locktype, nlocksneg, nlockspos), saying that infeasibility of c may lead to -# * infeasibility of the constraint's negation (i.e. feasibility of the constraint), and infeasibility of c's negation -# * (i.e. feasibility of c) may lead to infeasibility of the (positive) constraint. -# * - If the constraint may get violated by any change in the feasibility of the sub constraint c, it should call -# * SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg). -# * -# * Consider the or concatenation "c(x) or d(x)". The variable rounding lock method of the or constraint handler -# * should call SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg) and -# * SCIPaddConsLocksType(scip, d, locktype, nlockspos, nlocksneg) to tell SCIP, that infeasibility of c and d can lead -# * to infeasibility of "c(x) or d(x)". -# * -# * As a second example, consider the equivalence constraint "y <-> c(x)" with variable y and constraint c. The -# * constraint demands, that y == 1 if and only if c(x) is satisfied. The variable lock method of the corresponding -# * constraint handler should call SCIPaddVarLocksType(scip, y, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg) and -# * SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg), because any modification to the -# * value of y or to the feasibility of c can alter the feasibility of the equivalence constraint. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint that should lock rounding of its variables, or NULL if the constraint handler -# * does not need constraints -# * - locktype : type of rounding locks, i.e., SCIP_LOCKTYPE_MODEL or SCIP_LOCKTYPE_CONFLICT -# * - nlockspos : number of times, the roundings should be locked for the constraint (may be negative) -# * - nlocksneg : number of times, the roundings should be locked for the constraint's negation (may be negative) -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSLOCK ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_LOCKTYPE locktype , int nlockspos , int nlocksneg ) /** constraint activation notification method of constraint handler -# * -# * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but -# * the corresponding bound change event was not yet processed. -# * -# * This method is always called after a constraint of the constraint handler was activated. The constraint -# * handler may use this call to update his own (statistical) data. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint that has been activated -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSACTIVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) /** constraint deactivation notification method of constraint handler -# * -# * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but -# * the corresponding bound change event was not yet processed. -# * -# * This method is always called before a constraint of the constraint handler is deactivated. The constraint -# * handler may use this call to update his own (statistical) data. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint that will be deactivated -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSDEACTIVE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) /** constraint enabling notification method of constraint handler -# * -# * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but -# * the corresponding bound change event was not yet processed. -# * -# * This method is always called after a constraint of the constraint handler was enabled. The constraint -# * handler may use this call to update his own (statistical) data. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint that has been enabled -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSENABLE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) /** constraint disabling notification method of constraint handler -# * -# * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but -# * the corresponding bound change event was not yet processed. -# * -# * This method is always called before a constraint of the constraint handler is disabled. The constraint -# * handler may use this call to update his own (statistical) data. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint that will be disabled -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSDISABLE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons ) /** variable deletion method of constraint handler -# * -# * This method is optinal and only of interest if you are using SCIP as a branch-and-price framework. That means, you -# * are generating new variables during the search. If you are not doing that just define the function pointer to be -# * NULL. -# * -# * If this method gets implemented you should iterate over all constraints of the constraint handler and delete all -# * variables that were marked for deletion by SCIPdelVar(). -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - conss : array of constraints in transformed problem -# * - nconss : number of constraints in transformed problem -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSDELVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * conss , int nconss ) /** constraint display method of constraint handler -# * -# * The constraint handler can store a representation of the constraint into the given text file. Use the method -# * SCIPinfoMessage() to push a string into the file stream. -# * -# * @note There are several methods which help to display variables. These are SCIPwriteVarName(), SCIPwriteVarsList(), -# * SCIPwriteVarsLinearsum(), and SCIPwriteVarsPolynomial(). -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint that should be displayed -# * - file : the text file to store the information into -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSPRINT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , FILE * file ) /** constraint copying method of constraint handler -# * -# * The constraint handler can provide a copy method which copies a constraint from one SCIP data structure into an other -# * SCIP data structure. If a copy of a constraint is created, the constraint has to be captured. (The capture is usually -# * already done due to the creation of the constraint). -# * -# * If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, you have to set this pointer to -# * FALSE. In case all problem defining objects (constraint handlers and variable pricers) return a TRUE valid for all -# * their copying calls, SCIP assumes that it is a overall one to one copy of the original instance. In this case any -# * reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is -# * set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off. -# * -# * To get a copy of a variable in the target SCIP you should use the function SCIPgetVarCopy(). -# * -# * input: -# * - scip : target SCIP data structure -# * - cons : pointer to store the created target constraint -# * - name : name of constraint, or NULL if the name of the source constraint should be used -# * - sourcescip : source SCIP data structure -# * - sourceconshdlr : source constraint handler of the source SCIP -# * - sourcecons : source constraint of the source SCIP -# * - varmap : a SCIP_HASHMAP mapping variables of the source SCIP to corresponding variables of the target SCIP -# * - consmap : a SCIP_HASHMAP mapping constraints of the source SCIP to corresponding constraints of the target SCIP -# * - initial : should the LP relaxation of constraint be in the initial LP? -# * - separate : should the constraint be separated during LP processing? -# * - enforce : should the constraint be enforced during node processing? -# * - check : should the constraint be checked for feasibility? -# * - propagate : should the constraint be propagated during node processing? -# * - local : is constraint only valid locally? -# * - modifiable : is constraint modifiable (subject to column generation)? -# * - dynamic : is constraint subject to aging? -# * - removable : should the relaxation be removed from the LP due to aging or cleanup? -# * - stickingatnode : should the constraint always be kept at the node where it was added, even -# * if it may be moved to a more global node? -# * - global : should a global or a local copy be created? -# * -# * output: -# * - valid : pointer to store whether the copying was valid or not -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONS * * cons , const char * name , SCIP * sourcescip , SCIP_CONSHDLR * sourceconshdlr , SCIP_CONS * sourcecons , SCIP_HASHMAP * varmap , SCIP_HASHMAP * consmap , SCIP_Bool initial , SCIP_Bool separate , SCIP_Bool enforce , SCIP_Bool check , SCIP_Bool propagate , SCIP_Bool local , SCIP_Bool modifiable , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool stickingatnode , SCIP_Bool global , SCIP_Bool * valid ) /** constraint parsing method of constraint handler -# * -# * The constraint handler can provide a callback to parse the output created by the display method -# * (\ref SCIP_DECL_CONSPRINT) and to create a constraint out of it. -# * -# * @note For parsing there are several methods which are handy. Have a look at: SCIPparseVarName(), -# * SCIPparseVarsList(), SCIPparseVarsLinearsum(), SCIPparseVarsPolynomial(), SCIPstrToRealValue(), and -# * SCIPstrCopySection(). -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : pointer to store the created constraint -# * - name : name of the constraint -# * - str : string to parse -# * - initial : should the LP relaxation of constraint be in the initial LP? -# * - separate : should the constraint be separated during LP processing? -# * - enforce : should the constraint be enforced during node processing? -# * - check : should the constraint be checked for feasibility? -# * - propagate : should the constraint be propagated during node processing? -# * - local : is constraint only valid locally? -# * - modifiable : is constraint modifiable (subject to column generation)? -# * - dynamic : is constraint subject to aging? -# * - removable : should the relaxation be removed from the LP due to aging or cleanup? -# * - stickingatnode : should the constraint always be kept at the node where it was added, even -# * if it may be moved to a more global node? -# * output: -# * - success : pointer to store whether the parsing was successful or not -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSPARSE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * * cons , const char * name , const char * str , SCIP_Bool initial , SCIP_Bool separate , SCIP_Bool enforce , SCIP_Bool check , SCIP_Bool propagate , SCIP_Bool local , SCIP_Bool modifiable , SCIP_Bool dynamic , SCIP_Bool removable , SCIP_Bool stickingatnode , SCIP_Bool * success ) /** constraint method of constraint handler which returns the variables (if possible) -# * -# * The constraint handler can (this callback is optional) provide this callback to return the variables which are -# * involved in that particular constraint. If this is possible, the variables should be copyied into the variables -# * array and the success pointers has to be set to TRUE. Otherwise the success has to be set FALSE or the callback -# * should not be implemented. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : the constraint that should return its variable data -# * - varssize : available slots in vars array which is needed to check if the array is large enough -# * -# * output: -# * - vars : array to store/copy the involved variables of the constraint -# * - success : pointer to store whether the variables are successfully copied -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSGETVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , SCIP_VAR * * vars , int varssize , SCIP_Bool * success ) /** constraint method of constraint handler which returns the number of variables (if possible) -# * -# * The constraint handler can (this callback is optional) provide this callback to return the number variable which are -# * involved in that particular constraint. If this is not possible, the success pointers has to be set to FALSE or the -# * callback should not be implemented. -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - cons : constraint for which the number of variables is wanted -# * -# * output: -# * - nvars : pointer to store the number of variables -# * - success : pointer to store whether the constraint successfully returned the number of variables -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSGETNVARS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_CONS * cons , int * nvars , SCIP_Bool * success ) /** constraint handler method to suggest dive bound changes during the generic diving algorithm -# * -# * This callback is used inside the various diving heuristics of SCIP and does not affect the normal branching of the -# * actual search. The constraint handler can provide this callback to render the current solution (even more) -# * infeasible by suggesting one or several variable bound changes. In fact, since diving heuristics do not necessarily -# * solve LP relaxations at every probing depth, some of the variable local bounds might already be conflicting with the -# * solution values. The solution is rendered infeasible by determining bound changes that should be applied to the -# * next explored search node via SCIPaddDiveBoundChange(). An alternative in case that the preferred bound change(s) -# * were detected infeasible must be provided. -# * -# * The constraint handler must take care to only add bound changes that further shrink the variable domain. -# * -# * The success pointer must be used to indicate whether the constraint handler succeeded in selecting diving bound -# * changes. The infeasible pointer should be set to TRUE if the constraint handler found a local infeasibility. If the -# * constraint handler needs to select between several candidates, it may use the scoring mechanism of the diveset -# * argument to control its choice. -# * -# * This callback is optional. -# * -# * @note: @p sol is usually the LP relaxation solution unless the caller of the method, usually a diving heuristic, -# * does not solve LP relaxations at every depth -# * -# * input: -# * - scip : SCIP main data structure -# * - conshdlr : the constraint handler itself -# * - diveset : diving settings for scoring -# * - sol : current diving solution, usually the LP relaxation solution -# * -# * output: -# * - success : pointer to store whether the constraint handler succeeded to determine dive bound changes -# * - infeasible : pointer to store whether the constraint handler detected an infeasibility in the local node -# */ -# Skipping MacroDefinition: SCIP_DECL_CONSGETDIVEBDCHGS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_CONSHDLR * conshdlr , SCIP_DIVESET * diveset , SCIP_SOL * sol , SCIP_Bool * success , SCIP_Bool * infeasible ) # - -struct SCIP_Conshdlr -end - -const SCIP_CONSHDLR = Cvoid - -struct SCIP_Cons -end - -const SCIP_CONS = Cvoid - -struct SCIP_ConshdlrData -end - -const SCIP_CONSHDLRDATA = Cvoid - -struct SCIP_ConsData -end - -const SCIP_CONSDATA = Cvoid - -struct SCIP_ConsSetChg -end - -const SCIP_CONSSETCHG = Cvoid - -struct SCIP_LinConsStats -end - -const SCIP_LINCONSSTATS = Cvoid - -# begin enum SCIP_LinConstype -const SCIP_LinConstype = UInt32 -const SCIP_LINCONSTYPE_EMPTY = 0 |> UInt32 -const SCIP_LINCONSTYPE_FREE = 1 |> UInt32 -const SCIP_LINCONSTYPE_SINGLETON = 2 |> UInt32 -const SCIP_LINCONSTYPE_AGGREGATION = 3 |> UInt32 -const SCIP_LINCONSTYPE_PRECEDENCE = 4 |> UInt32 -const SCIP_LINCONSTYPE_VARBOUND = 5 |> UInt32 -const SCIP_LINCONSTYPE_SETPARTITION = 6 |> UInt32 -const SCIP_LINCONSTYPE_SETPACKING = 7 |> UInt32 -const SCIP_LINCONSTYPE_SETCOVERING = 8 |> UInt32 -const SCIP_LINCONSTYPE_CARDINALITY = 9 |> UInt32 -const SCIP_LINCONSTYPE_INVKNAPSACK = 10 |> UInt32 -const SCIP_LINCONSTYPE_EQKNAPSACK = 11 |> UInt32 -const SCIP_LINCONSTYPE_BINPACKING = 12 |> UInt32 -const SCIP_LINCONSTYPE_KNAPSACK = 13 |> UInt32 -const SCIP_LINCONSTYPE_INTKNAPSACK = 14 |> UInt32 -const SCIP_LINCONSTYPE_MIXEDBINARY = 15 |> UInt32 -const SCIP_LINCONSTYPE_GENERAL = 16 |> UInt32 -# end enum SCIP_LinConstype - -const SCIP_LINCONSTYPE = SCIP_LinConstype - -struct SCIP_Cutpool -end - -const SCIP_CUTPOOL = Cvoid - -struct SCIP_Cut -end - -const SCIP_CUT = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_DIALOGCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) /** destructor of dialog to free user data (called when the dialog is not captured anymore) -# * -# * input: -# * - scip : SCIP main data structure -# * - dialog : the dialog itself -# */ -# Skipping MacroDefinition: SCIP_DECL_DIALOGFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) /** description output method of dialog -# * -# * This method should output (usually a single line of) information describing the meaning of the dialog. -# * The method is called, when the help menu of the parent's dialog is displayed. -# * If no description output method is given, the description string of the dialog is displayed instead. -# * -# * input: -# * - scip : SCIP main data structure -# * - *dialog : the dialog itself -# */ -# Skipping MacroDefinition: SCIP_DECL_DIALOGDESC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog ) /** execution method of dialog -# * -# * This method is invoked, if the user selected the dialog's command name in the parent's dialog menu. -# * -# * input: -# * - scip : SCIP main data structure -# * - dialoghdlr : dialog handler to call for user interaction -# * - dialog : the dialog itself -# * -# * output: -# * - *nextdialog : next dialog to process (or NULL to quit dialog processing) -# */ -# Skipping MacroDefinition: SCIP_DECL_DIALOGEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIALOG * dialog , SCIP_DIALOGHDLR * dialoghdlr , SCIP_DIALOG * * nextdialog ) # - -struct SCIP_Dialog -end - -const SCIP_DIALOG = Cvoid - -struct SCIP_DialogData -end - -const SCIP_DIALOGDATA = Cvoid - -struct SCIP_Dialoghdlr -end - -const SCIP_DIALOGHDLR = Cvoid - -struct SCIP_Linelist -end - -const SCIP_LINELIST = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_DISPCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** destructor of display column to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - disp : the display column itself -# */ -# Skipping MacroDefinition: SCIP_DECL_DISPFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** initialization method of display column (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - disp : the display column itself -# */ -# Skipping MacroDefinition: SCIP_DECL_DISPINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** deinitialization method of display column (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - disp : the display column itself -# */ -# Skipping MacroDefinition: SCIP_DECL_DISPEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** solving process initialization method of display column (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The display column may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - disp : the display column itself -# */ -# Skipping MacroDefinition: SCIP_DECL_DISPINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** solving process deinitialization method of display column (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The display column should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - disp : the display column itself -# */ -# Skipping MacroDefinition: SCIP_DECL_DISPEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp ) /** output method of display column to output file stream 'file' -# * -# * input: -# * - scip : SCIP main data structure -# * - disp : the display column itself -# * - file : file stream for output -# */ -# Skipping MacroDefinition: SCIP_DECL_DISPOUTPUT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DISP * disp , FILE * file ) # - -# begin enum SCIP_DispStatus -const SCIP_DispStatus = UInt32 -const SCIP_DISPSTATUS_OFF = 0 |> UInt32 -const SCIP_DISPSTATUS_AUTO = 1 |> UInt32 -const SCIP_DISPSTATUS_ON = 2 |> UInt32 -# end enum SCIP_DispStatus - -const SCIP_DISPSTATUS = SCIP_DispStatus - -# begin enum SCIP_DispMode -const SCIP_DispMode = UInt32 -const SCIP_DISPMODE_DEFAULT = 1 |> UInt32 -const SCIP_DISPMODE_CONCURRENT = 2 |> UInt32 -const SCIP_DISPMODE_ALL = 3 |> UInt32 -# end enum SCIP_DispMode - -const SCIP_DISPMODE = SCIP_DispMode - -struct SCIP_Disp -end - -const SCIP_DISP = Cvoid - -struct SCIP_DispData -end - -const SCIP_DISPDATA = Cvoid -const SCIP_DIVETYPE_NONE = UInt32(0x0000) -const SCIP_DIVETYPE_INTEGRALITY = UInt32(0x0001) -const SCIP_DIVETYPE_SOS1VARIABLE = UInt32(0x0002) - -# Skipping MacroDefinition: SCIP_DECL_HEURCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** destructor of primal heuristic to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - heur : the primal heuristic itself -# */ -# Skipping MacroDefinition: SCIP_DECL_HEURFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** initialization method of primal heuristic (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - heur : the primal heuristic itself -# */ -# Skipping MacroDefinition: SCIP_DECL_HEURINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** deinitialization method of primal heuristic (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - heur : the primal heuristic itself -# */ -# Skipping MacroDefinition: SCIP_DECL_HEUREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** solving process initialization method of primal heuristic (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The primal heuristic may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - heur : the primal heuristic itself -# */ -# Skipping MacroDefinition: SCIP_DECL_HEURINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** solving process deinitialization method of primal heuristic (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The primal heuristic should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - heur : the primal heuristic itself -# */ -# Skipping MacroDefinition: SCIP_DECL_HEUREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur ) /** execution method of primal heuristic -# * -# * Searches for feasible primal solutions. The method is called in the node processing loop. -# * -# * input: -# * - scip : SCIP main data structure -# * - heur : the primal heuristic itself -# * - heurtiming : current point in the node solving loop -# * - nodeinfeasible : was the current node already detected to be infeasible? -# * - result : pointer to store the result of the heuristic call -# * -# * possible return values for *result: -# * - SCIP_FOUNDSOL : at least one feasible primal solution was found -# * - SCIP_DIDNOTFIND : the heuristic searched, but did not find a feasible solution -# * - SCIP_DIDNOTRUN : the heuristic was skipped -# * - SCIP_DELAYED : the heuristic was skipped, but should be called again as soon as possible, disregarding -# * its frequency -# */ -# Skipping MacroDefinition: SCIP_DECL_HEUREXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_HEUR * heur , SCIP_HEURTIMING heurtiming , SCIP_Bool nodeinfeasible , SCIP_RESULT * result ) /* callbacks for diving heuristic specific settings */ -# Skipping MacroDefinition: SCIP_DECL_DIVESETGETSCORE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_DIVESET * diveset , SCIP_DIVETYPE divetype , SCIP_VAR * cand , SCIP_Real candsol , SCIP_Real candsfrac , SCIP_Real * score , SCIP_Bool * roundup ) # - -const SCIP_DIVETYPE = UInt32 - -struct SCIP_Heur -end - -const SCIP_HEUR = Cvoid - -struct SCIP_HeurData -end - -const SCIP_HEURDATA = Cvoid - -struct SCIP_Diveset -end - -const SCIP_DIVESET = Cvoid - -struct SCIP_VGraph -end - -const SCIP_VGRAPH = Cvoid - -# begin enum SCIP_BranchDir -const SCIP_BranchDir = UInt32 -const SCIP_BRANCHDIR_DOWNWARDS = 0 |> UInt32 -const SCIP_BRANCHDIR_UPWARDS = 1 |> UInt32 -const SCIP_BRANCHDIR_FIXED = 2 |> UInt32 -const SCIP_BRANCHDIR_AUTO = 3 |> UInt32 -# end enum SCIP_BranchDir - -const SCIP_BRANCHDIR = SCIP_BranchDir - -struct SCIP_History -end - -const SCIP_HISTORY = Cvoid - -struct SCIP_ValueHistory -end - -const SCIP_VALUEHISTORY = Cvoid - -struct SCIP_VBounds -end - -const SCIP_VBOUNDS = Cvoid - -struct SCIP_Implics -end - -const SCIP_IMPLICS = Cvoid - -struct SCIP_Clique -end - -const SCIP_CLIQUE = Cvoid - -struct SCIP_CliqueTable -end - -const SCIP_CLIQUETABLE = Cvoid - -struct SCIP_CliqueList -end - -const SCIP_CLIQUELIST = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_MESSAGEOUTPUTFUNC ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) /** error message print method -# * -# * This method is invoked, if SCIP wants to display an error message to the screen or a file. -# * -# * @note This function is independent of any message handler. -# * -# * input: -# * - data : data pointer -# * - file : file stream to print into -# * - msg : string to output into the file (or NULL to flush) -# */ -# Skipping MacroDefinition: SCIP_DECL_ERRORPRINTING ( x ) void x ( void * data , FILE * file , const char * msg ) /** warning message print method of message handler -# * -# * This method is invoked, if SCIP wants to display a warning message to the screen or a file. -# * -# * input: -# * - messagehdlr : the message handler itself -# * - file : file stream to print into -# * - msg : string to output into the file (or NULL to flush) -# */ -# Skipping MacroDefinition: SCIP_DECL_MESSAGEWARNING ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) /** dialog message print method of message handler -# * -# * This method is invoked, if SCIP wants to display a dialog message to the screen or a file. -# * -# * input: -# * - messagehdlr : the message handler itself -# * - file : file stream to print into -# * - msg : string to output into the file (or NULL to flush) -# */ -# Skipping MacroDefinition: SCIP_DECL_MESSAGEDIALOG ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) /** info message print method of message handler -# * -# * This method is invoked, if SCIP wants to display an information message to the screen or a file. -# * -# * input: -# * - messagehdlr : the message handler itself -# * - file : file stream to print into -# * - msg : string to output into the file (or NULL to flush) -# */ -# Skipping MacroDefinition: SCIP_DECL_MESSAGEINFO ( x ) void x ( SCIP_MESSAGEHDLR * messagehdlr , FILE * file , const char * msg ) /** destructor of message handler to free message handler data -# * -# * This method is invoked, if SCIP wants to free a message handler. -# * -# * input: -# * - messagehdlr : the message handler itself -# */ -# Skipping MacroDefinition: SCIP_DECL_MESSAGEHDLRFREE ( x ) SCIP_RETCODE x ( SCIP_MESSAGEHDLR * messagehdlr ) # - -# begin enum SCIP_VerbLevel -const SCIP_VerbLevel = UInt32 -const SCIP_VERBLEVEL_NONE = 0 |> UInt32 -const SCIP_VERBLEVEL_DIALOG = 1 |> UInt32 -const SCIP_VERBLEVEL_MINIMAL = 2 |> UInt32 -const SCIP_VERBLEVEL_NORMAL = 3 |> UInt32 -const SCIP_VERBLEVEL_HIGH = 4 |> UInt32 -const SCIP_VERBLEVEL_FULL = 5 |> UInt32 -# end enum SCIP_VerbLevel - -const SCIP_VERBLEVEL = SCIP_VerbLevel - -struct SCIP_Messagehdlr -end - -const SCIP_MESSAGEHDLR = Cvoid - -struct SCIP_MessagehdlrData -end - -const SCIP_MESSAGEHDLRDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_NODESELCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** destructor of node selector to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - nodesel : the node selector itself -# */ -# Skipping MacroDefinition: SCIP_DECL_NODESELFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** initialization method of node selector (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - nodesel : the node selector itself -# */ -# Skipping MacroDefinition: SCIP_DECL_NODESELINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** deinitialization method of node selector (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - nodesel : the node selector itself -# */ -# Skipping MacroDefinition: SCIP_DECL_NODESELEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** solving process initialization method of node selector (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The node selector may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - nodesel : the node selector itself -# */ -# Skipping MacroDefinition: SCIP_DECL_NODESELINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** solving process deinitialization method of node selector (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The node selector should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - nodesel : the node selector itself -# */ -# Skipping MacroDefinition: SCIP_DECL_NODESELEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel ) /** node selection method of node selector -# * -# * This method is called to select the next leaf of the branch and bound tree to be processed. -# * -# * input: -# * - scip : SCIP main data structure -# * - nodesel : the node selector itself -# * - selnode : pointer to store the selected node -# * -# * possible return values for *selnode: -# * - NULL : problem is solved, because tree is empty -# * - non-NULL: node to be solved next -# */ -# Skipping MacroDefinition: SCIP_DECL_NODESELSELECT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_NODESEL * nodesel , SCIP_NODE * * selnode ) /** node comparison method of node selector -# * -# * This method is called to compare two nodes regarding their order in the node priority queue. -# * -# * input: -# * - scip : SCIP main data structure -# * - nodesel : the node selector itself -# * - node1 : first node to compare -# * - node2 : second node to compare -# * -# * possible return values: -# * - value < 0: node1 comes before (is better than) node2 -# * - value = 0: both nodes are equally good -# * - value > 0: node2 comes after (is worse than) node2 -# */ -# Skipping MacroDefinition: SCIP_DECL_NODESELCOMP ( x ) int x ( SCIP * scip , SCIP_NODESEL * nodesel , SCIP_NODE * node1 , SCIP_NODE * node2 ) # - -struct SCIP_NodePQ -end - -const SCIP_NODEPQ = Cvoid - -struct SCIP_Nodesel -end - -const SCIP_NODESEL = Cvoid - -struct SCIP_NodeselData -end - -const SCIP_NODESELDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_PRESOLCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** destructor of presolver to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - presol : the presolver itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRESOLFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** initialization method of presolver (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - presol : the presolver itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRESOLINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** deinitialization method of presolver (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - presol : the presolver itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRESOLEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** presolving initialization method of presolver (called when presolving is about to begin) -# * -# * This method is called when the presolving process is about to begin, even if presolving is turned off. -# * The presolver may use this call to initialize its data structures. -# * -# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the -# * presolving deinitialization call (SCIP_DECL_PRESOLSEXITPRE()). -# * -# * input: -# * - scip : SCIP main data structure -# * - presol : the presolver itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRESOLINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** presolving deinitialization method of presolver (called after presolving has been finished) -# * -# * This method is called after the presolving has been finished, even if presolving is turned off. -# * The presolver may use this call e.g. to clean up or modify its data structures. -# * -# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the -# * presolving initialization call (SCIP_DECL_PRESOLINITPRE()). -# * -# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the -# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, -# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. -# * -# * input: -# * - scip : SCIP main data structure -# * - presol : the presolver itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRESOLEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol ) /** execution method of presolver -# * -# * The presolver should go through the variables and constraints and tighten the domains or -# * constraints. Each tightening should increase the given total numbers of changes. -# * -# * input: -# * - scip : SCIP main data structure -# * - presol : the presolver itself -# * - nrounds : number of presolving rounds already done -# * - presoltiming : current presolving timing -# * - nnewfixedvars : number of variables fixed since the last call to the presolver -# * - nnewaggrvars : number of variables aggregated since the last call to the presolver -# * - nnewchgvartypes : number of variable type changes since the last call to the presolver -# * - nnewchgbds : number of variable bounds tightened since the last call to the presolver -# * - nnewholes : number of domain holes added since the last call to the presolver -# * - nnewdelconss : number of deleted constraints since the last call to the presolver -# * - nnewaddconss : number of added constraints since the last call to the presolver -# * - nnewupgdconss : number of upgraded constraints since the last call to the presolver -# * - nnewchgcoefs : number of changed coefficients since the last call to the presolver -# * - nnewchgsides : number of changed left or right hand sides since the last call to the presolver -# * -# * @note the counters state the changes since the last call including the changes of this presolver during its last -# * last call -# * -# * @note if the presolver uses dual information it is nesassary to check via calling SCIPallowDualReds if dual -# * reductions are allowed. -# * -# * input/output: -# * - nfixedvars : pointer to total number of variables fixed of all presolvers -# * - naggrvars : pointer to total number of variables aggregated of all presolvers -# * - nchgvartypes : pointer to total number of variable type changes of all presolvers -# * - nchgbds : pointer to total number of variable bounds tightened of all presolvers -# * - naddholes : pointer to total number of domain holes added of all presolvers -# * - ndelconss : pointer to total number of deleted constraints of all presolvers -# * - naddconss : pointer to total number of added constraints of all presolvers -# * - nupgdconss : pointer to total number of upgraded constraints of all presolvers -# * - nchgcoefs : pointer to total number of changed coefficients of all presolvers -# * - nchgsides : pointer to total number of changed left/right hand sides of all presolvers -# * -# * output: -# * - result : pointer to store the result of the presolving call -# * -# * possible return values for *result: -# * - SCIP_UNBOUNDED : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded -# * - SCIP_CUTOFF : at least one constraint is infeasible in the variable's bounds -> problem is infeasible -# * - SCIP_SUCCESS : the presolver found a reduction -# * - SCIP_DIDNOTFIND : the presolver searched, but did not find a presolving change -# * - SCIP_DIDNOTRUN : the presolver was skipped -# */ -# Skipping MacroDefinition: SCIP_DECL_PRESOLEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRESOL * presol , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) # - -struct SCIP_Presol -end - -const SCIP_PRESOL = Cvoid - -struct SCIP_PresolData -end - -const SCIP_PRESOLDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_PRICERCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_Bool * valid ) /** destructor of variable pricer to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - pricer : the variable pricer itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRICERFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** initialization method of variable pricer (called after problem was transformed and pricer is active) -# * -# * input: -# * - scip : SCIP main data structure -# * - pricer : the variable pricer itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRICERINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** deinitialization method of variable pricer (called before transformed problem is freed and pricer is active) -# * -# * input: -# * - scip : SCIP main data structure -# * - pricer : the variable pricer itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRICEREXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** solving process initialization method of variable pricer (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The variable pricer may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - pricer : the variable pricer itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRICERINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** solving process deinitialization method of variable pricer (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The variable pricer should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - pricer : the variable pricer itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PRICEREXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer ) /** reduced cost pricing method of variable pricer for feasible LPs -# * -# * Searches for variables that can contribute to improve the current LP's solution value. -# * In standard branch-and-price, these are variables with negative dual feasibility, that is negative -# * reduced costs for non-negative variables, positive reduced costs for non-positive variables, -# * and non-zero reduced costs for variables that can be negative and positive. -# * -# * The method is called in the LP solving loop after an LP was proven to be feasible. -# * -# * Whenever the pricer finds a variable with negative dual feasibility, it should call SCIPcreateVar() -# * and SCIPaddPricedVar() to add the variable to the problem. Furthermore, it should call the appropriate -# * methods of the constraint handlers to add the necessary variable entries to the constraints. -# * -# * In the usual case that the pricer either adds a new variable or ensures that there are no further variables with -# * negative dual feasibility, the result pointer should be set to SCIP_SUCCESS. Only if the pricer aborts pricing -# * without creating a new variable, but there might exist additional variables with negative dual feasibility, the -# * result pointer should be set to SCIP_DIDNOTRUN. In this case, which sometimes is referred to as "early branching", -# * the lp solution will not be used as a lower bound. The pricer can, however, store a valid lower bound in the -# * lowerbound pointer. If you use your own branching rule (e.g., to branch on constraints), make sure that it is able -# * to branch on pseudo solutions. Otherwise, SCIP will use its default branching rules (which all branch on -# * variables). This could disturb the pricing problem or branching might not even be possible, e.g., if all yet created -# * variables have already been fixed. -# * -# * input: -# * - scip : SCIP main data structure -# * - pricer : the variable pricer itself -# * - lowerbound : pointer to store a lower bound found by the pricer -# * - stopearly : should pricing be stopped, although new variables were added? (doing early branching) -# * - result : pointer to store the result of the pricer call -# * -# * possible return values for *result: -# * - SCIP_SUCCESS : at least one improving variable was found, or it is ensured that no such variable exists -# * - SCIP_DIDNOTRUN : the pricing process was aborted by the pricer, there is no guarantee that the current LP solution is -# * optimal -# * -# */ -# Skipping MacroDefinition: SCIP_DECL_PRICERREDCOST ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_Real * lowerbound , SCIP_Bool * stopearly , SCIP_RESULT * result ) /** Farkas pricing method of variable pricer for infeasible LPs -# * -# * Searches for variables that can contribute to the feasibility of the current LP. -# * In standard branch-and-price, these are variables with positive Farkas values: -# * -# * The LP was proven infeasible, so we have an infeasibility proof by the dual Farkas multipliers y. -# * With the values of y, an implicit inequality y^T A x >= y^T b is associated, with b given -# * by the sides of the LP rows and the sign of y: -# * - if y_i is positive, b_i is the left hand side of the row, -# * - if y_i is negative, b_i is the right hand side of the row. -# * -# * y is chosen in a way, such that the valid inequality y^T A x >= y^T b is violated by all x, -# * especially by the (for this inequality least infeasible solution) x' defined by -# * x'_i := ub_i, if y^T A_i >= 0 -# * x'_i := lb_i, if y^T A_i < 0. -# * Pricing in this case means to add variables i with positive Farkas value, i.e. y^T A_i x'_i > 0. -# * -# * The method is called in the LP solving loop after an LP was proven to be infeasible. -# * -# * Whenever the pricer finds a variable with positive Farkas value, it should call SCIPcreateVar() -# * and SCIPaddPricedVar() to add the variable to the problem. Furthermore, it should call the appropriate -# * methods of the constraint handlers to add the necessary variable entries to the constraints. -# * -# * input: -# * - scip : SCIP main data structure -# * - pricer : the variable pricer itself -# * - result : pointer to store the result of the pricer call -# * -# * possible return values for *result: -# * - SCIP_SUCCESS : at least one variable was found, which can contribute to the feasibility of the current LP, -# * or it is ensured that no such variable exists -# * - SCIP_DIDNOTRUN : the pricing process was aborted by the pricer, there is no guarantee that the current LP is indeed infeasible -# */ -# Skipping MacroDefinition: SCIP_DECL_PRICERFARKAS ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PRICER * pricer , SCIP_RESULT * result ) # - -struct SCIP_Pricer -end - -const SCIP_PRICER = Cvoid - -struct SCIP_PricerData -end - -const SCIP_PRICERDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_PROPCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** destructor of propagator to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** initialization method of propagator (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** deinitialization method of propagator (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** presolving initialization method of propagator (called when presolving is about to begin) -# * -# * This method is called when the presolving process is about to begin, even if presolving is turned off. The -# * propagator may use this call to initialize its presolving data, before the presolving process begins. -# * -# * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the -# * presolving deinitialization call (SCIP_DECL_PROPEXITPRE()). -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPINITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** presolving deinitialization method of propagator (called after presolving has been finished) -# * -# * This method is called after the presolving has been finished, even if presolving is turned off. -# * The propagator may use this call e.g. to clean up its presolving data. -# * -# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the -# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, -# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPEXITPRE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** solving process initialization method of propagator (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The propagator may use this call to initialize its branch and bound specific data. -# * -# * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the -# * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, -# * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop ) /** solving process deinitialization method of propagator (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The propagator should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# * - restart : was this exit solve call triggered by a restart? -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_Bool restart ) /** presolving method of propagator -# * -# * The presolver should go through the variables and constraints and tighten the domains or -# * constraints. Each tightening should increase the given total numbers of changes. -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# * - nrounds : number of presolving rounds already done -# * - presoltiming : current presolving timing -# * - nnewfixedvars : number of variables fixed since the last call to the presolving method -# * - nnewaggrvars : number of variables aggregated since the last call to the presolving method -# * - nnewchgvartypes : number of variable type changes since the last call to the presolving method -# * - nnewchgbds : number of variable bounds tightened since the last call to the presolving method -# * - nnewholes : number of domain holes added since the last call to the presolving method -# * - nnewdelconss : number of deleted constraints since the last call to the presolving method -# * - nnewaddconss : number of added constraints since the last call to the presolving method -# * - nnewupgdconss : number of upgraded constraints since the last call to the presolving method -# * - nnewchgcoefs : number of changed coefficients since the last call to the presolving method -# * - nnewchgsides : number of changed left or right hand sides since the last call to the presolving method -# * -# * @note the counters state the changes since the last call including the changes of this presolving method during its -# * last call -# * -# * @note if the propagator uses dual information for presolving it is nesassary to check via calling SCIPallowDualReds -# * if dual reductions are allowed. -# * -# * input/output: -# * - nfixedvars : pointer to total number of variables fixed of all presolvers -# * - naggrvars : pointer to total number of variables aggregated of all presolvers -# * - nchgvartypes : pointer to total number of variable type changes of all presolvers -# * - nchgbds : pointer to total number of variable bounds tightened of all presolvers -# * - naddholes : pointer to total number of domain holes added of all presolvers -# * - ndelconss : pointer to total number of deleted constraints of all presolvers -# * - naddconss : pointer to total number of added constraints of all presolvers -# * - nupgdconss : pointer to total number of upgraded constraints of all presolvers -# * - nchgcoefs : pointer to total number of changed coefficients of all presolvers -# * - nchgsides : pointer to total number of changed left/right hand sides of all presolvers -# * -# * output: -# * - result : pointer to store the result of the presolving call -# * -# * possible return values for *result: -# * - SCIP_UNBOUNDED : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded -# * - SCIP_CUTOFF : at least one constraint is infeasible in the variable's bounds -> problem is infeasible -# * - SCIP_SUCCESS : the presolving method found a reduction -# * - SCIP_DIDNOTFIND : the presolving method searched, but did not find a presolving change -# * - SCIP_DIDNOTRUN : the presolving method was skipped -# * - SCIP_DELAYED : the presolving method was skipped, but should be called again -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPPRESOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , int nrounds , SCIP_PRESOLTIMING presoltiming , int nnewfixedvars , int nnewaggrvars , int nnewchgvartypes , int nnewchgbds , int nnewholes , int nnewdelconss , int nnewaddconss , int nnewupgdconss , int nnewchgcoefs , int nnewchgsides , int * nfixedvars , int * naggrvars , int * nchgvartypes , int * nchgbds , int * naddholes , int * ndelconss , int * naddconss , int * nupgdconss , int * nchgcoefs , int * nchgsides , SCIP_RESULT * result ) /** execution method of propagator -# * -# * Searches for domain propagations. The method is called in the node processing loop. -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# * - proptiming : current point in the node solving loop -# * - result : pointer to store the result of the propagation call -# * -# * possible return values for *result: -# * - SCIP_CUTOFF : the current node is infeasible for the current domains -# * - SCIP_REDUCEDDOM : at least one domain reduction was found -# * - SCIP_DIDNOTFIND : the propagator searched, but did not find a domain reduction -# * - SCIP_DIDNOTRUN : the propagator was skipped -# * - SCIP_DELAYED : the propagator was skipped, but should be called again -# * - SCIP_DELAYNODE : the current node should be postponed (return value only valid for BEFORELP propagation) -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_PROPTIMING proptiming , SCIP_RESULT * result ) /** propagation conflict resolving method of propagator -# * -# * This method is called during conflict analysis. If the propagator wants to support conflict analysis, -# * it should call SCIPinferVarLbProp() or SCIPinferVarUbProp() in domain propagation instead of SCIPchgVarLb() or -# * SCIPchgVarUb() in order to deduce bound changes on variables. -# * In the SCIPinferVarLbProp() and SCIPinferVarUbProp() calls, the propagator provides a pointer to itself -# * and an integer value "inferinfo" that can be arbitrarily chosen. -# * The propagation conflict resolving method can then be implemented, to provide a "reasons" for the bound -# * changes, i.e. the bounds of variables at the time of the propagation, that forced the propagator to set the -# * conflict variable's bound to its current value. It can use the "inferinfo" tag to identify its own propagation -# * rule and thus identify the "reason" bounds. The bounds that form the reason of the assignment must then be provided -# * by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), -# * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and/or SCIPaddConflictBinvar() in the propagation conflict -# * resolving method. -# * -# * See the description of the propagation conflict resolving method of constraint handlers for further details. -# * -# * @note if the propagtor uses dual information it is nesassary to check via calling SCIPallowDualReds and -# * SCIPallowObjProp if dual reductions and propgation with the current cutoff bound, resp., are allowed. -# * -# * input: -# * - scip : SCIP main data structure -# * - prop : the propagator itself -# * - infervar : the conflict variable whose bound change has to be resolved -# * - inferinfo : the user information passed to the corresponding SCIPinferVarLbProp() or SCIPinferVarUbProp() call -# * - boundtype : the type of the changed bound (lower or upper bound) -# * - bdchgidx : the index of the bound change, representing the point of time where the change took place -# * - relaxedbd : the relaxed bound which is sufficient to be explained -# * -# * output: -# * - result : pointer to store the result of the propagation conflict resolving call -# * -# * possible return values for *result: -# * - SCIP_SUCCESS : the conflicting bound change has been successfully resolved by adding all reason bounds -# * - SCIP_DIDNOTFIND : the conflicting bound change could not be resolved and has to be put into the conflict set -# * -# * @note it is sufficient to explain/resolve the relaxed bound -# */ -# Skipping MacroDefinition: SCIP_DECL_PROPRESPROP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_PROP * prop , SCIP_VAR * infervar , int inferinfo , SCIP_BOUNDTYPE boundtype , SCIP_BDCHGIDX * bdchgidx , SCIP_Real relaxedbd , SCIP_RESULT * result ) # - -struct SCIP_Prop -end - -const SCIP_PROP = Cvoid - -struct SCIP_PropData -end - -const SCIP_PROPDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_READERCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader ) /** destructor of reader to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - reader : the reader itself -# */ -# Skipping MacroDefinition: SCIP_DECL_READERFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader ) /** problem reading method of reader -# * -# * input: -# * - scip : SCIP main data structure -# * - reader : the reader itself -# * - filename : full path and name of file to read, or NULL if stdin should be used -# * - result : pointer to store the result of the file reading call -# * -# * possible return values for *result: -# * - SCIP_SUCCESS : the reader read the file correctly and created an appropriate problem -# * - SCIP_DIDNOTRUN : the reader is not responsible for given input file -# * -# * If the reader detected an error in the input file, it should return with RETCODE SCIP_READERROR or SCIP_NOFILE. -# */ -# Skipping MacroDefinition: SCIP_DECL_READERREAD ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader , const char * filename , SCIP_RESULT * result ) /** problem writing method of reader; NOTE: if the parameter "genericnames" is TRUE, then -# * SCIP already set all variable and constraint names to generic names; therefore, this -# * method should always use SCIPvarGetName() and SCIPconsGetName(); -# * -# * input: -# * - scip : SCIP main data structure -# * - reader : the reader itself -# * - file : output file, or NULL if standard output should be used -# * - name : problem name -# * - probdata : user problem data set by the reader -# * - transformed : TRUE iff problem is the transformed problem -# * - objsense : objective sense -# * - objscale : scalar applied to objective function; external objective value is -# extobj = objsense * objscale * (intobj + objoffset) -# * - objoffset : objective offset from bound shifting and fixing -# * - vars : array with active variables ordered binary, integer, implicit, continuous -# * - nvars : number of active variables in the problem -# * - nbinvars : number of binary variables -# * - nintvars : number of general integer variables -# * - nimplvars : number of implicit integer variables -# * - ncontvars; : number of continuous variables -# * - fixedvars : array with fixed and aggregated variables -# * - nfixedvars : number of fixed and aggregated variables in the problem -# * - startnvars : number of variables existing when problem solving started -# * - conss : array with constraints of the problem -# * - nconss : number of constraints in the problem -# * - maxnconss : maximum number of constraints existing at the same time -# * - startnconss : number of constraints existing when problem solving started -# * - genericnames : using generic variable and constraint names? -# * - result : pointer to store the result of the file reading call -# * -# * possible return values for *result: -# * - SCIP_SUCCESS : the reader wrote the file correctly -# * - SCIP_DIDNOTRUN : the reader is not responsible for given input file -# * -# * If the reader detected an error while writing the output file, it should return with RETCODE SCIP_WRITEERROR -# */ -# Skipping MacroDefinition: SCIP_DECL_READERWRITE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_READER * reader , FILE * file , const char * name , SCIP_PROBDATA * probdata , SCIP_Bool transformed , SCIP_OBJSENSE objsense , SCIP_Real objscale , SCIP_Real objoffset , SCIP_VAR * * vars , int nvars , int nbinvars , int nintvars , int nimplvars , int ncontvars , SCIP_VAR * * fixedvars , int nfixedvars , int startnvars , SCIP_CONS * * conss , int nconss , int maxnconss , int startnconss , SCIP_Bool genericnames , SCIP_RESULT * result ) # - -struct SCIP_Reader -end - -const SCIP_READER = Cvoid - -struct SCIP_ReaderData -end - -const SCIP_READERDATA = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_RELAXCOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** destructor of relaxator to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - relax : the relaxator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_RELAXFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** initialization method of relaxator (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - relax : the relaxator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_RELAXINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** deinitialization method of relaxator (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - relax : the relaxator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_RELAXEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** solving process initialization method of relaxator (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The relaxator may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - relax : the relaxator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_RELAXINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** solving process deinitialization method of relaxator (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The relaxator should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - relax : the relaxator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_RELAXEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax ) /** execution method of relaxator -# * -# * The method is called in the node processing loop. It solves the current subproblem's relaxation. -# * Like the LP relaxation, the relaxator should only operate on COLUMN variables. -# * -# * input: -# * - scip : SCIP main data structure -# * - relax : the relaxator itself -# * - lowerbound : pointer to store a lowerbound for the current node -# * - result : pointer to store the result of the relaxation call -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_CONSADDED : an additional constraint was generated, and the relaxator should not be called again on the -# * same relaxation -# * - SCIP_REDUCEDDOM : a variable's domain was reduced, and the relaxator should not be called again on the same -# * relaxation -# * - SCIP_SEPARATED : a cutting plane was generated, and the relaxator should not be called again on the same relaxation -# * - SCIP_SUCCESS : the relaxator solved the relaxation and should not be called again on the same relaxation -# * - SCIP_SUSPENDED : the relaxator interrupted its solving process to wait for additional input (e.g. cutting -# * planes); however, it is able to continue the solving in order to improve the dual bound -# * - SCIP_DIDNOTRUN : the relaxator was skipped -# */ -# Skipping MacroDefinition: SCIP_DECL_RELAXEXEC ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_RELAX * relax , SCIP_Real * lowerbound , SCIP_RESULT * result ) # - -struct SCIP_Relax -end - -const SCIP_RELAX = Cvoid - -struct SCIP_Relaxation -end - -const SCIP_RELAXATION = Cvoid - -struct SCIP_RelaxData -end - -const SCIP_RELAXDATA = Cvoid - -struct SCIP_Reopt -end - -const SCIP_REOPT = Cvoid - -struct SCIP_SolTree -end - -const SCIP_SOLTREE = Cvoid - -struct SCIP_SolNode -end - -const SCIP_SOLNODE = Cvoid - -struct SCIP_ReoptTree -end - -const SCIP_REOPTTREE = Cvoid - -struct SCIP_ReoptNode -end - -const SCIP_REOPTNODE = Cvoid -const SCIP_REPRESENTATIVE = Cvoid - -struct SCIP_ReoptConsData -end - -const SCIP_REOPTCONSDATA = Cvoid - -# begin enum SCIP_ReoptType -const SCIP_ReoptType = UInt32 -const SCIP_REOPTTYPE_NONE = 0 |> UInt32 -const SCIP_REOPTTYPE_TRANSIT = 1 |> UInt32 -const SCIP_REOPTTYPE_INFSUBTREE = 2 |> UInt32 -const SCIP_REOPTTYPE_STRBRANCHED = 3 |> UInt32 -const SCIP_REOPTTYPE_LOGICORNODE = 4 |> UInt32 -const SCIP_REOPTTYPE_LEAF = 5 |> UInt32 -const SCIP_REOPTTYPE_PRUNED = 6 |> UInt32 -const SCIP_REOPTTYPE_FEASIBLE = 7 |> UInt32 -# end enum SCIP_ReoptType - -const SCIP_REOPTTYPE = SCIP_ReoptType - -# begin enum Reopt_ConsType -const Reopt_ConsType = UInt32 -const REOPT_CONSTYPE_INFSUBTREE = 0 |> UInt32 -const REOPT_CONSTYPE_DUALREDS = 1 |> UInt32 -const REOPT_CONSTYPE_CUT = 2 |> UInt32 -const REOPT_CONSTYPE_UNKNOWN = 3 |> UInt32 -# end enum Reopt_ConsType - -const REOPT_CONSTYPE = Reopt_ConsType - -# Skipping MacroDefinition: SCIP_DECL_SEPACOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** destructor of separator to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - sepa : the separator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_SEPAFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** initialization method of separator (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - sepa : the separator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_SEPAINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** deinitialization method of separator (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - sepa : the separator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_SEPAEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** solving process initialization method of separator (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The separator may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - sepa : the separator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_SEPAINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** solving process deinitialization method of separator (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The separator should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - sepa : the separator itself -# */ -# Skipping MacroDefinition: SCIP_DECL_SEPAEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) /** LP solution separation method of separator -# * -# * Searches for cutting planes that separate the current LP solution. The method is called in the LP solving loop, -# * which means that a valid LP solution exists. -# * -# * input: -# * - scip : SCIP main data structure -# * - sepa : the separator itself -# * - result : pointer to store the result of the separation call -# * - allowlocal : should the separator allow local cuts? -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_CONSADDED : an additional constraint was generated -# * - SCIP_REDUCEDDOM : a variable's domain was reduced -# * - SCIP_SEPARATED : a cutting plane was generated -# * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start -# * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints -# * - SCIP_DIDNOTRUN : the separator was skipped -# * - SCIP_DELAYED : the separator was skipped, but should be called again -# */ -# Skipping MacroDefinition: SCIP_DECL_SEPAEXECLP ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa , SCIP_RESULT * result , SCIP_Bool allowlocal ) /** arbitrary primal solution separation method of separator -# * -# * Searches for cutting planes that separate the given primal solution. The method is called outside the LP solution -# * loop (e.g., by a relaxator or a primal heuristic), which means that there is no valid LP solution. -# * -# * input: -# * - scip : SCIP main data structure -# * - sepa : the separator itself -# * - sol : primal solution that should be separated -# * - result : pointer to store the result of the separation call -# * - allowlocal : should the separator allow local cuts? -# * -# * possible return values for *result (if more than one applies, the first in the list should be used): -# * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off -# * - SCIP_CONSADDED : an additional constraint was generated -# * - SCIP_REDUCEDDOM : a variable's domain was reduced -# * - SCIP_SEPARATED : a cutting plane was generated -# * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start -# * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints -# * - SCIP_DIDNOTRUN : the separator was skipped -# * - SCIP_DELAYED : the separator was skipped, but should be called again -# */ -# Skipping MacroDefinition: SCIP_DECL_SEPAEXECSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa , SCIP_SOL * sol , SCIP_RESULT * result , SCIP_Bool allowlocal ) # - -struct SCIP_Sepa -end - -const SCIP_SEPA = Cvoid - -struct SCIP_SepaData -end - -const SCIP_SEPADATA = Cvoid - -# begin enum SCIP_Stage -const SCIP_Stage = UInt32 -const SCIP_STAGE_INIT = 0 |> UInt32 -const SCIP_STAGE_PROBLEM = 1 |> UInt32 -const SCIP_STAGE_TRANSFORMING = 2 |> UInt32 -const SCIP_STAGE_TRANSFORMED = 3 |> UInt32 -const SCIP_STAGE_INITPRESOLVE = 4 |> UInt32 -const SCIP_STAGE_PRESOLVING = 5 |> UInt32 -const SCIP_STAGE_EXITPRESOLVE = 6 |> UInt32 -const SCIP_STAGE_PRESOLVED = 7 |> UInt32 -const SCIP_STAGE_INITSOLVE = 8 |> UInt32 -const SCIP_STAGE_SOLVING = 9 |> UInt32 -const SCIP_STAGE_SOLVED = 10 |> UInt32 -const SCIP_STAGE_EXITSOLVE = 11 |> UInt32 -const SCIP_STAGE_FREETRANS = 12 |> UInt32 -const SCIP_STAGE_FREE = 13 |> UInt32 -# end enum SCIP_Stage - -const SCIP_STAGE = SCIP_Stage - -# begin enum SCIP_Setting -const SCIP_Setting = UInt32 -const SCIP_UNDEFINED = 0 |> UInt32 -const SCIP_DISABLED = 1 |> UInt32 -const SCIP_AUTO = 2 |> UInt32 -const SCIP_ENABLED = 3 |> UInt32 -# end enum SCIP_Setting - -const SCIP_SETTING = SCIP_Setting - -struct SCIP_Set -end - -const SCIP_SET = Cvoid - -# begin enum SCIP_SolOrigin -const SCIP_SolOrigin = UInt32 -const SCIP_SOLORIGIN_ORIGINAL = 0 |> UInt32 -const SCIP_SOLORIGIN_ZERO = 1 |> UInt32 -const SCIP_SOLORIGIN_LPSOL = 2 |> UInt32 -const SCIP_SOLORIGIN_NLPSOL = 3 |> UInt32 -const SCIP_SOLORIGIN_RELAXSOL = 4 |> UInt32 -const SCIP_SOLORIGIN_PSEUDOSOL = 5 |> UInt32 -const SCIP_SOLORIGIN_PARTIAL = 6 |> UInt32 -const SCIP_SOLORIGIN_UNKNOWN = 7 |> UInt32 -# end enum SCIP_SolOrigin - -const SCIP_SOLORIGIN = SCIP_SolOrigin - -struct SCIP_Sol -end - -const SCIP_SOL = Cvoid - -struct SCIP_Viol -end - -const SCIP_VIOL = Cvoid - -# begin enum SCIP_Status -const SCIP_Status = UInt32 -const SCIP_STATUS_UNKNOWN = 0 |> UInt32 -const SCIP_STATUS_USERINTERRUPT = 1 |> UInt32 -const SCIP_STATUS_NODELIMIT = 2 |> UInt32 -const SCIP_STATUS_TOTALNODELIMIT = 3 |> UInt32 -const SCIP_STATUS_STALLNODELIMIT = 4 |> UInt32 -const SCIP_STATUS_TIMELIMIT = 5 |> UInt32 -const SCIP_STATUS_MEMLIMIT = 6 |> UInt32 -const SCIP_STATUS_GAPLIMIT = 7 |> UInt32 -const SCIP_STATUS_SOLLIMIT = 8 |> UInt32 -const SCIP_STATUS_BESTSOLLIMIT = 9 |> UInt32 -const SCIP_STATUS_RESTARTLIMIT = 10 |> UInt32 -const SCIP_STATUS_OPTIMAL = 11 |> UInt32 -const SCIP_STATUS_INFEASIBLE = 12 |> UInt32 -const SCIP_STATUS_UNBOUNDED = 13 |> UInt32 -const SCIP_STATUS_INFORUNBD = 14 |> UInt32 -const SCIP_STATUS_TERMINATE = 15 |> UInt32 -# end enum SCIP_Status - -const SCIP_STATUS = SCIP_Status - -struct SCIP_Stat -end - -const SCIP_STAT = Cvoid - -# begin enum SCIP_Parallelmode -const SCIP_Parallelmode = UInt32 -const SCIP_PARA_OPPORTUNISTIC = 0 |> UInt32 -const SCIP_PARA_DETERMINISTIC = 1 |> UInt32 -# end enum SCIP_Parallelmode - -const SCIP_PARALLELMODE = SCIP_Parallelmode - -struct SCIP_SyncStore -end - -const SCIP_SYNCSTORE = Cvoid - -struct SCIP_SyncData -end - -const SCIP_SYNCDATA = Cvoid - -struct SCIP_BoundStore -end - -const SCIP_BOUNDSTORE = Cvoid - -# Skipping MacroDefinition: SCIP_DECL_TABLECOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** destructor of statistics table to free user data (called when SCIP is exiting) -# * -# * input: -# * - scip : SCIP main data structure -# * - table : the statistics table itself -# */ -# Skipping MacroDefinition: SCIP_DECL_TABLEFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** initialization method of statistics table (called after problem was transformed) -# * -# * input: -# * - scip : SCIP main data structure -# * - table : the statistics table itself -# */ -# Skipping MacroDefinition: SCIP_DECL_TABLEINIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** deinitialization method of statistics table (called before transformed problem is freed) -# * -# * input: -# * - scip : SCIP main data structure -# * - table : the statistics table itself -# */ -# Skipping MacroDefinition: SCIP_DECL_TABLEEXIT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** solving process initialization method of statistics table (called when branch and bound process is about to begin) -# * -# * This method is called when the presolving was finished and the branch and bound process is about to begin. -# * The statistics table may use this call to initialize its branch and bound specific data. -# * -# * input: -# * - scip : SCIP main data structure -# * - table : the statistics table itself -# */ -# Skipping MacroDefinition: SCIP_DECL_TABLEINITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** solving process deinitialization method of statistics table (called before branch and bound process data is freed) -# * -# * This method is called before the branch and bound process is freed. -# * The statistics table should use this call to clean up its branch and bound data. -# * -# * input: -# * - scip : SCIP main data structure -# * - table : the display column itself -# */ -# Skipping MacroDefinition: SCIP_DECL_TABLEEXITSOL ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table ) /** output method of statistics table to output file stream 'file' -# * -# * input: -# * - scip : SCIP main data structure -# * - table : the statistics table itself -# * - file : file stream for output -# */ -# Skipping MacroDefinition: SCIP_DECL_TABLEOUTPUT ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_TABLE * table , FILE * file ) # - -struct SCIP_Table -end - -const SCIP_TABLE = Cvoid - -struct SCIP_TableData -end - -const SCIP_TABLEDATA = Cvoid - -struct SCIP_Concurrent -end - -const SCIP_CONCURRENT = Cvoid - -struct SCIP_ConflictStore -end - -const SCIP_CONFLICTSTORE = Cvoid - -struct SCIP_AggrRow -end - -const SCIP_AGGRROW = Cvoid - -struct SCIP_Interrupt -end - -const SCIP_INTERRUPT = Cvoid - -struct SCIP_Matrix -end - -const SCIP_MATRIX = Cvoid - -struct SCIP_Mem -end - -const SCIP_MEM = Cvoid - -struct SCIP_Pricestore -end - -const SCIP_PRICESTORE = Cvoid - -struct SCIP_Primal -end - -const SCIP_PRIMAL = Cvoid - -# begin enum SCIP_Efficiacychoice -const SCIP_Efficiacychoice = UInt32 -const SCIP_EFFICIACYCHOICE_LP = 0 |> UInt32 -const SCIP_EFFICIACYCHOICE_RELAX = 1 |> UInt32 -const SCIP_EFFICIACYCHOICE_NLP = 2 |> UInt32 -# end enum SCIP_Efficiacychoice - -const SCIP_EFFICIACYCHOICE = SCIP_Efficiacychoice - -struct SCIP_SepaStore -end - -const SCIP_SEPASTORE = Cvoid - -# begin enum SCIP_VBCColor -const SCIP_VBCColor = Cint -const SCIP_VBCCOLOR_UNSOLVED = 3 |> Int32 -const SCIP_VBCCOLOR_SOLVED = 2 |> Int32 -const SCIP_VBCCOLOR_CUTOFF = 4 |> Int32 -const SCIP_VBCCOLOR_CONFLICT = 15 |> Int32 -const SCIP_VBCCOLOR_MARKREPROP = 11 |> Int32 -const SCIP_VBCCOLOR_REPROP = 12 |> Int32 -const SCIP_VBCCOLOR_SOLUTION = 14 |> Int32 -const SCIP_VBCCOLOR_NONE = -1 |> Int32 -# end enum SCIP_VBCColor +const SCIP_DomChgBound = Cvoid +const SCIP_DOMCHGBOUND = SCIP_DomChgBound +const SCIP_DomChgBoth = Cvoid +const SCIP_DOMCHGBOTH = SCIP_DomChgBoth +const SCIP_DomChgDyn = Cvoid +const SCIP_DOMCHGDYN = SCIP_DomChgDyn +const SCIP_DomChg = Cvoid +const SCIP_DOMCHG = SCIP_DomChg +const SCIP_BoundChg = Cvoid +const SCIP_BOUNDCHG = SCIP_BoundChg +const SCIP_BdChgIdx = Cvoid +const SCIP_BDCHGIDX = SCIP_BdChgIdx +const SCIP_BdChgInfo = Cvoid +const SCIP_BDCHGINFO = SCIP_BdChgInfo +const SCIP_BranchingData = Cvoid +const SCIP_BRANCHINGDATA = SCIP_BranchingData +const SCIP_InferenceData = Cvoid +const SCIP_INFERENCEDATA = SCIP_InferenceData +const SCIP_HoleChg = Cvoid +const SCIP_HOLECHG = SCIP_HoleChg +const SCIP_Hole = Cvoid +const SCIP_HOLE = SCIP_Hole +const SCIP_Holelist = Cvoid +const SCIP_HOLELIST = SCIP_Holelist +const SCIP_Dom = Cvoid +const SCIP_DOM = SCIP_Dom +const SCIP_Original = Cvoid +const SCIP_ORIGINAL = SCIP_Original +const SCIP_Aggregate = Cvoid +const SCIP_AGGREGATE = SCIP_Aggregate +const SCIP_Multaggr = Cvoid +const SCIP_MULTAGGR = SCIP_Multaggr +const SCIP_Negate = Cvoid +const SCIP_NEGATE = SCIP_Negate +const SCIP_Var = Cvoid +const SCIP_VAR = SCIP_Var +const SCIP_VarData = Cvoid +const SCIP_VARDATA = SCIP_VarData + +@cenum(SCIP_VBCColor{Int32}, + SCIP_VBCCOLOR_UNSOLVED = 3, + SCIP_VBCCOLOR_SOLVED = 2, + SCIP_VBCCOLOR_CUTOFF = 4, + SCIP_VBCCOLOR_CONFLICT = 15, + SCIP_VBCCOLOR_MARKREPROP = 11, + SCIP_VBCCOLOR_REPROP = 12, + SCIP_VBCCOLOR_SOLUTION = 14, + SCIP_VBCCOLOR_NONE = -1, +) const SCIP_VBCCOLOR = SCIP_VBCColor - -struct SCIP_Visual -end - -const SCIP_VISUAL = Cvoid - -# Skipping MacroDefinition: SCIPallocMemory ( scip , ptr ) ( ( BMSallocMemory ( ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocMemoryArray ( scip , ptr , num ) ( ( BMSallocMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocClearMemoryArray ( scip , ptr , num ) ( ( BMSallocClearMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocMemorySize ( scip , ptr , size ) ( ( BMSallocMemorySize ( ( ptr ) , ( size ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPreallocMemoryArray ( scip , ptr , newnum ) ( ( BMSreallocMemoryArray ( ( ptr ) , ( newnum ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPreallocMemorySize ( scip , ptr , newsize ) ( ( BMSreallocMemorySize ( ( ptr ) , ( newsize ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPduplicateMemory ( scip , ptr , source ) ( ( BMSduplicateMemory ( ( ptr ) , ( source ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPduplicateMemoryArray ( scip , ptr , source , num ) ( ( BMSduplicateMemoryArray ( ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPfreeMemory ( scip , ptr ) BMSfreeMemory ( ptr ) # -# Skipping MacroDefinition: SCIPfreeMemoryNull ( scip , ptr ) BMSfreeMemoryNull ( ptr ) # -# Skipping MacroDefinition: SCIPfreeMemoryArray ( scip , ptr ) BMSfreeMemoryArray ( ptr ) # -# Skipping MacroDefinition: SCIPfreeMemoryArrayNull ( scip , ptr ) BMSfreeMemoryArrayNull ( ptr ) # -# Skipping MacroDefinition: SCIPfreeMemorySize ( scip , ptr ) BMSfreeMemorySize ( ptr ) # -# Skipping MacroDefinition: SCIPfreeMemorySizeNull ( scip , ptr ) BMSfreeMemorySizeNull ( ptr ) /* Block Memory Management Macros -# * -# */ -# Skipping MacroDefinition: SCIPallocBlockMemory ( scip , ptr ) ( ( BMSallocBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocBlockMemoryArray ( scip , ptr , num ) ( ( BMSallocBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocBlockMemorySize ( scip , ptr , size ) ( ( BMSallocBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocClearBlockMemoryArray ( scip , ptr , num ) ( ( BMSallocClearBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPreallocBlockMemoryArray ( scip , ptr , oldnum , newnum ) ( ( BMSreallocBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( oldnum ) , ( newnum ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPreallocBlockMemorySize ( scip , ptr , oldsize , newsize ) ( ( BMSreallocBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( oldsize ) , ( newsize ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPduplicateBlockMemory ( scip , ptr , source ) ( ( BMSduplicateBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) , ( source ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPduplicateBlockMemoryArray ( scip , ptr , source , num ) ( ( BMSduplicateBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPensureBlockMemoryArray ( scip , ptr , arraysizeptr , minsize ) ( ( SCIPensureBlockMemoryArray_call ( ( scip ) , ( void * * ) ( ptr ) , sizeof ( * * ( ptr ) ) , ( arraysizeptr ) , ( minsize ) ) ) ) # -# Skipping MacroDefinition: SCIPfreeBlockMemory ( scip , ptr ) BMSfreeBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPfreeBlockMemoryNull ( scip , ptr ) BMSfreeBlockMemoryNull ( SCIPblkmem ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPfreeBlockMemoryArray ( scip , ptr , num ) BMSfreeBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) # -# Skipping MacroDefinition: SCIPfreeBlockMemoryArrayNull ( scip , ptr , num ) BMSfreeBlockMemoryArrayNull ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) # -# Skipping MacroDefinition: SCIPfreeBlockMemorySize ( scip , ptr , size ) BMSfreeBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) # -# Skipping MacroDefinition: SCIPfreeBlockMemorySizeNull ( scip , ptr , size ) BMSfreeBlockMemorySizeNull ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) /* Buffer Memory Management Macros -# * -# * -# */ -# Skipping MacroDefinition: SCIPallocBuffer ( scip , ptr ) ( ( BMSallocBufferMemory ( SCIPbuffer ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocBufferArray ( scip , ptr , num ) ( ( BMSallocBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocClearBufferArray ( scip , ptr , num ) ( ( BMSallocClearBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPreallocBufferArray ( scip , ptr , num ) ( ( BMSreallocBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPduplicateBuffer ( scip , ptr , source ) ( ( BMSduplicateBufferMemory ( SCIPbuffer ( scip ) , ( ptr ) , ( source ) , ( size_t ) sizeof ( * * ( ptr ) ) ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPduplicateBufferArray ( scip , ptr , source , num ) ( ( BMSduplicateBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPfreeBuffer ( scip , ptr ) BMSfreeBufferMemorySize ( SCIPbuffer ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPfreeBufferNull ( scip , ptr ) BMSfreeBufferMemoryNull ( SCIPbuffer ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPfreeBufferArray ( scip , ptr ) BMSfreeBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPfreeBufferArrayNull ( scip , ptr ) BMSfreeBufferMemoryArrayNull ( SCIPbuffer ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPallocCleanBuffer ( scip , ptr ) ( ( BMSallocBufferMemory ( SCIPcleanbuffer ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPallocCleanBufferArray ( scip , ptr , num ) ( ( BMSallocBufferMemoryArray ( SCIPcleanbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # -# Skipping MacroDefinition: SCIPfreeCleanBuffer ( scip , ptr ) BMSfreeBufferMemorySize ( SCIPcleanbuffer ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPfreeCleanBufferNull ( scip , ptr ) BMSfreeBufferMemoryNull ( SCIPcleanbuffer ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPfreeCleanBufferArray ( scip , ptr ) BMSfreeBufferMemoryArray ( SCIPcleanbuffer ( scip ) , ( ptr ) ) # -# Skipping MacroDefinition: SCIPfreeCleanBufferArrayNull ( scip , ptr ) BMSfreeBufferMemoryArrayNull ( SCIPcleanbuffer ( scip ) , ( ptr ) ) /* Memory Management Functions -# * -# * -# */ -# Skipping MacroDefinition: SCIPdebugMsg ( scip , ... ) while ( FALSE ) SCIPprintDebugMessage ( scip , __FILE__ , __LINE__ , __VA_ARGS__ ) # -# Skipping MacroDefinition: SCIPdebugMsgPrint ( scip , ... ) while ( FALSE ) SCIPdebugMessagePrint ( scip , __VA_ARGS__ ) # +const SCIP_Visual = Cvoid +const SCIP_VISUAL = SCIP_Visual + +# Skipping MacroDefinition: SCIPallocMemory ( scip , ptr ) ( ( BMSallocMemory ( ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocMemoryArray ( scip , ptr , num ) ( ( BMSallocMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocClearMemoryArray ( scip , ptr , num ) ( ( BMSallocClearMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocMemorySize ( scip , ptr , size ) ( ( BMSallocMemorySize ( ( ptr ) , ( size ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPreallocMemoryArray ( scip , ptr , newnum ) ( ( BMSreallocMemoryArray ( ( ptr ) , ( newnum ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPreallocMemorySize ( scip , ptr , newsize ) ( ( BMSreallocMemorySize ( ( ptr ) , ( newsize ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPduplicateMemory ( scip , ptr , source ) ( ( BMSduplicateMemory ( ( ptr ) , ( source ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPduplicateMemoryArray ( scip , ptr , source , num ) ( ( BMSduplicateMemoryArray ( ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPfreeMemory ( scip , ptr ) BMSfreeMemory ( ptr ) +# Skipping MacroDefinition: SCIPfreeMemoryNull ( scip , ptr ) BMSfreeMemoryNull ( ptr ) +# Skipping MacroDefinition: SCIPfreeMemoryArray ( scip , ptr ) BMSfreeMemoryArray ( ptr ) +# Skipping MacroDefinition: SCIPfreeMemoryArrayNull ( scip , ptr ) BMSfreeMemoryArrayNull ( ptr ) +# Skipping MacroDefinition: SCIPfreeMemorySize ( scip , ptr ) BMSfreeMemorySize ( ptr ) +# Skipping MacroDefinition: SCIPfreeMemorySizeNull ( scip , ptr ) BMSfreeMemorySizeNull ( ptr ) +# Skipping MacroDefinition: SCIPallocBlockMemory ( scip , ptr ) ( ( BMSallocBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocBlockMemoryArray ( scip , ptr , num ) ( ( BMSallocBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocBlockMemorySize ( scip , ptr , size ) ( ( BMSallocBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocClearBlockMemoryArray ( scip , ptr , num ) ( ( BMSallocClearBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPreallocBlockMemoryArray ( scip , ptr , oldnum , newnum ) ( ( BMSreallocBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( oldnum ) , ( newnum ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPreallocBlockMemorySize ( scip , ptr , oldsize , newsize ) ( ( BMSreallocBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( oldsize ) , ( newsize ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPduplicateBlockMemory ( scip , ptr , source ) ( ( BMSduplicateBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) , ( source ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPduplicateBlockMemoryArray ( scip , ptr , source , num ) ( ( BMSduplicateBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPensureBlockMemoryArray ( scip , ptr , arraysizeptr , minsize ) ( ( SCIPensureBlockMemoryArray_call ( ( scip ) , ( void * * ) ( ptr ) , sizeof ( * * ( ptr ) ) , ( arraysizeptr ) , ( minsize ) ) ) ) +# Skipping MacroDefinition: SCIPfreeBlockMemory ( scip , ptr ) BMSfreeBlockMemory ( SCIPblkmem ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPfreeBlockMemoryNull ( scip , ptr ) BMSfreeBlockMemoryNull ( SCIPblkmem ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPfreeBlockMemoryArray ( scip , ptr , num ) BMSfreeBlockMemoryArray ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) +# Skipping MacroDefinition: SCIPfreeBlockMemoryArrayNull ( scip , ptr , num ) BMSfreeBlockMemoryArrayNull ( SCIPblkmem ( scip ) , ( ptr ) , ( num ) ) +# Skipping MacroDefinition: SCIPfreeBlockMemorySize ( scip , ptr , size ) BMSfreeBlockMemorySize ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) +# Skipping MacroDefinition: SCIPfreeBlockMemorySizeNull ( scip , ptr , size ) BMSfreeBlockMemorySizeNull ( SCIPblkmem ( scip ) , ( ptr ) , ( size ) ) +# Skipping MacroDefinition: SCIPallocBuffer ( scip , ptr ) ( ( BMSallocBufferMemory ( SCIPbuffer ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocBufferArray ( scip , ptr , num ) ( ( BMSallocBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocClearBufferArray ( scip , ptr , num ) ( ( BMSallocClearBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPreallocBufferArray ( scip , ptr , num ) ( ( BMSreallocBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPduplicateBuffer ( scip , ptr , source ) ( ( BMSduplicateBufferMemory ( SCIPbuffer ( scip ) , ( ptr ) , ( source ) , ( size_t ) sizeof ( * * ( ptr ) ) ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPduplicateBufferArray ( scip , ptr , source , num ) ( ( BMSduplicateBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) , ( source ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPfreeBuffer ( scip , ptr ) BMSfreeBufferMemorySize ( SCIPbuffer ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPfreeBufferNull ( scip , ptr ) BMSfreeBufferMemoryNull ( SCIPbuffer ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPfreeBufferArray ( scip , ptr ) BMSfreeBufferMemoryArray ( SCIPbuffer ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPfreeBufferArrayNull ( scip , ptr ) BMSfreeBufferMemoryArrayNull ( SCIPbuffer ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPallocCleanBuffer ( scip , ptr ) ( ( BMSallocBufferMemory ( SCIPcleanbuffer ( scip ) , ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPallocCleanBufferArray ( scip , ptr , num ) ( ( BMSallocBufferMemoryArray ( SCIPcleanbuffer ( scip ) , ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) +# Skipping MacroDefinition: SCIPfreeCleanBuffer ( scip , ptr ) BMSfreeBufferMemorySize ( SCIPcleanbuffer ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPfreeCleanBufferNull ( scip , ptr ) BMSfreeBufferMemoryNull ( SCIPcleanbuffer ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPfreeCleanBufferArray ( scip , ptr ) BMSfreeBufferMemoryArray ( SCIPcleanbuffer ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPfreeCleanBufferArrayNull ( scip , ptr ) BMSfreeBufferMemoryArrayNull ( SCIPcleanbuffer ( scip ) , ( ptr ) ) +# Skipping MacroDefinition: SCIPdebugMsg ( scip , ... ) while ( FALSE ) SCIPprintDebugMessage ( scip , __FILE__ , __LINE__ , __VA_ARGS__ ) +# Skipping MacroDefinition: SCIPdebugMsgPrint ( scip , ... ) while ( FALSE ) SCIPdebugMessagePrint ( scip , __VA_ARGS__ ) diff --git a/src/wrapper/ctypes.jl b/src/wrapper/ctypes.jl new file mode 100644 index 00000000..436e6ad0 --- /dev/null +++ b/src/wrapper/ctypes.jl @@ -0,0 +1,7 @@ +## TODO: pending https://github.com/JuliaLang/julia/issues/29420 +# this one is suggested in the issue, but it looks like time_t and tm are two different things? +# const Ctime_t = Base.Libc.TmStruct + +const Ctm = Base.Libc.TmStruct +const Ctime_t = UInt +const Cclock_t = UInt diff --git a/src/wrapper/scip_bandit.jl b/src/wrapper/scip_bandit.jl index 364df688..a7c90b55 100644 --- a/src/wrapper/scip_bandit.jl +++ b/src/wrapper/scip_bandit.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_bandit.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPincludeBanditvtable(scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) @@ -14,6 +14,6 @@ function SCIPfreeBandit(scip, bandit) ccall((:SCIPfreeBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}), scip, bandit) end -function SCIPresetBandit(scip, bandit, priorities, seed::UInt32) +function SCIPresetBandit(scip, bandit, priorities, seed) ccall((:SCIPresetBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BANDIT}, Ptr{Cdouble}, UInt32), scip, bandit, priorities, seed) end diff --git a/src/wrapper/scip_benders.jl b/src/wrapper/scip_benders.jl index 459481d4..bf59f198 100644 --- a/src/wrapper/scip_benders.jl +++ b/src/wrapper/scip_benders.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_benders.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeBenders(scip, name, desc, priority::Cint, cutlp::UInt32, cutpseudo::UInt32, cutrelax::UInt32, shareauxvars::UInt32, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre, bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex, benderssolvesub, benderspostsolve, bendersfreesub, bendersdata) +function SCIPincludeBenders(scip, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre, bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex, benderssolvesub, benderspostsolve, bendersfreesub, bendersdata) ccall((:SCIPincludeBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre, bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex, benderssolvesub, benderspostsolve, bendersfreesub, bendersdata) end -function SCIPincludeBendersBasic(scip, bendersptr, name, desc, priority::Cint, cutlp::UInt32, cutpseudo::UInt32, cutrelax::UInt32, shareauxvars::UInt32, bendersgetvar, benderscreatesub, bendersdata) +function SCIPincludeBendersBasic(scip, bendersptr, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, bendersgetvar, benderscreatesub, bendersdata) ccall((:SCIPincludeBendersBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BENDERS}}, Cstring, Cstring, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, bendersptr, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, bendersgetvar, benderscreatesub, bendersdata) end @@ -70,7 +70,7 @@ function SCIPgetNActiveBenders(scip) ccall((:SCIPgetNActiveBenders, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPactivateBenders(scip, benders, nsubproblems::Cint) +function SCIPactivateBenders(scip, benders, nsubproblems) ccall((:SCIPactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, nsubproblems) end @@ -78,11 +78,11 @@ function SCIPdeactivateBenders(scip, benders) ccall((:SCIPdeactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) end -function SCIPsetBendersPriority(scip, benders, priority::Cint) +function SCIPsetBendersPriority(scip, benders, priority) ccall((:SCIPsetBendersPriority, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, priority) end -function SCIPsolveBendersSubproblems(scip, benders, sol, result, infeasible, auxviol, type::SCIP_BENDERSENFOTYPE, checkint::UInt32) +function SCIPsolveBendersSubproblems(scip, benders, sol, result, infeasible, auxviol, type, checkint) ccall((:SCIPsolveBendersSubproblems, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}, Ptr{UInt32}, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32), scip, benders, sol, result, infeasible, auxviol, type, checkint) end @@ -90,7 +90,7 @@ function SCIPgetBendersMasterVar(scip, benders, var, mappedvar) ccall((:SCIPgetBendersMasterVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, benders, var, mappedvar) end -function SCIPgetBendersSubproblemVar(scip, benders, var, mappedvar, probnumber::Cint) +function SCIPgetBendersSubproblemVar(scip, benders, var, mappedvar, probnumber) ccall((:SCIPgetBendersSubproblemVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, benders, var, mappedvar, probnumber) end @@ -102,39 +102,39 @@ function SCIPaddBendersSubproblem(scip, benders, subproblem) ccall((:SCIPaddBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP}), scip, benders, subproblem) end -function SCIPsetupBendersSubproblem(scip, benders, sol, probnumber::Cint) +function SCIPsetupBendersSubproblem(scip, benders, sol, probnumber) ccall((:SCIPsetupBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) end -function SCIPsolveBendersSubproblem(scip, benders, sol, probnumber::Cint, infeasible, type::SCIP_BENDERSENFOTYPE, solvecip::UInt32, objective) +function SCIPsolveBendersSubproblem(scip, benders, sol, probnumber, infeasible, type, solvecip, objective) ccall((:SCIPsolveBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32, Ptr{Cdouble}), scip, benders, sol, probnumber, infeasible, type, solvecip, objective) end -function SCIPfreeBendersSubproblem(scip, benders, probnumber::Cint) +function SCIPfreeBendersSubproblem(scip, benders, probnumber) ccall((:SCIPfreeBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, probnumber) end -function SCIPcheckBendersSubproblemOptimality(scip, benders, sol, probnumber::Cint, optimal) +function SCIPcheckBendersSubproblemOptimality(scip, benders, sol, probnumber, optimal) ccall((:SCIPcheckBendersSubproblemOptimality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}), scip, benders, sol, probnumber, optimal) end -function SCIPgetBendersAuxiliaryVarVal(scip, benders, sol, probnumber::Cint) +function SCIPgetBendersAuxiliaryVarVal(scip, benders, sol, probnumber) ccall((:SCIPgetBendersAuxiliaryVarVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) end -function SCIPcomputeBendersSubproblemLowerbound(scip, benders, probnumber::Cint, lowerbound, infeasible) +function SCIPcomputeBendersSubproblemLowerbound(scip, benders, probnumber, lowerbound, infeasible) ccall((:SCIPcomputeBendersSubproblemLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{Cdouble}, Ptr{UInt32}), scip, benders, probnumber, lowerbound, infeasible) end -function SCIPmergeBendersSubproblemIntoMaster(scip, benders, varmap, consmap, probnumber::Cint) +function SCIPmergeBendersSubproblemIntoMaster(scip, benders, varmap, consmap, probnumber) ccall((:SCIPmergeBendersSubproblemIntoMaster, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cint), scip, benders, varmap, consmap, probnumber) end -function SCIPincludeBenderscut(scip, benders, name, desc, priority::Cint, islpcut::UInt32, benderscutcopy, benderscutfree, benderscutinit, benderscutexit, benderscutinitsol, benderscutexitsol, benderscutexec, benderscutdata) +function SCIPincludeBenderscut(scip, benders, name, desc, priority, islpcut, benderscutcopy, benderscutfree, benderscutinit, benderscutexit, benderscutinitsol, benderscutexitsol, benderscutexec, benderscutdata) ccall((:SCIPincludeBenderscut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, name, desc, priority, islpcut, benderscutcopy, benderscutfree, benderscutinit, benderscutexit, benderscutinitsol, benderscutexitsol, benderscutexec, benderscutdata) end -function SCIPincludeBenderscutBasic(scip, benders, benderscutptr, name, desc, priority::Cint, islpcut::UInt32, benderscutexec, benderscutdata) +function SCIPincludeBenderscutBasic(scip, benders, benderscutptr, name, desc, priority, islpcut, benderscutexec, benderscutdata) ccall((:SCIPincludeBenderscutBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Ptr{SCIP_BENDERSCUT}}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, benderscutptr, name, desc, priority, islpcut, benderscutexec, benderscutdata) end @@ -162,7 +162,7 @@ function SCIPsetBenderscutExitsol(scip, benderscut, benderscutexitsol) ccall((:SCIPsetBenderscutExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexitsol) end -function SCIPsetBenderscutPriority(scip, benderscut, priority::Cint) +function SCIPsetBenderscutPriority(scip, benderscut, priority) ccall((:SCIPsetBenderscutPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Cint), scip, benderscut, priority) end diff --git a/src/wrapper/scip_branch.jl b/src/wrapper/scip_branch.jl index d802312f..6af42520 100644 --- a/src/wrapper/scip_branch.jl +++ b/src/wrapper/scip_branch.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_branch.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeBranchrule(scip, name, desc, priority::Cint, maxdepth::Cint, maxbounddist::Cdouble, branchcopy, branchfree, branchinit, branchexit, branchinitsol, branchexitsol, branchexeclp, branchexecext, branchexecps, branchruledata) +function SCIPincludeBranchrule(scip, name, desc, priority, maxdepth, maxbounddist, branchcopy, branchfree, branchinit, branchexit, branchinitsol, branchexitsol, branchexeclp, branchexecext, branchexecps, branchruledata) ccall((:SCIPincludeBranchrule, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BRANCHRULEDATA}), scip, name, desc, priority, maxdepth, maxbounddist, branchcopy, branchfree, branchinit, branchexit, branchinitsol, branchexitsol, branchexeclp, branchexecext, branchexecps, branchruledata) end -function SCIPincludeBranchruleBasic(scip, branchruleptr, name, desc, priority::Cint, maxdepth::Cint, maxbounddist::Cdouble, branchruledata) +function SCIPincludeBranchruleBasic(scip, branchruleptr, name, desc, priority, maxdepth, maxbounddist, branchruledata) ccall((:SCIPincludeBranchruleBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BRANCHRULE}}, Cstring, Cstring, Cint, Cint, Cdouble, Ptr{SCIP_BRANCHRULEDATA}), scip, branchruleptr, name, desc, priority, maxdepth, maxbounddist, branchruledata) end @@ -58,15 +58,15 @@ function SCIPgetNBranchrules(scip) ccall((:SCIPgetNBranchrules, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetBranchrulePriority(scip, branchrule, priority::Cint) +function SCIPsetBranchrulePriority(scip, branchrule, priority) ccall((:SCIPsetBranchrulePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, priority) end -function SCIPsetBranchruleMaxdepth(scip, branchrule, maxdepth::Cint) +function SCIPsetBranchruleMaxdepth(scip, branchrule, maxdepth) ccall((:SCIPsetBranchruleMaxdepth, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, maxdepth) end -function SCIPsetBranchruleMaxbounddist(scip, branchrule, maxbounddist::Cdouble) +function SCIPsetBranchruleMaxbounddist(scip, branchrule, maxbounddist) ccall((:SCIPsetBranchruleMaxbounddist, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cdouble), scip, branchrule, maxbounddist) end @@ -110,7 +110,7 @@ function SCIPgetNPrioExternBranchConts(scip) ccall((:SCIPgetNPrioExternBranchConts, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPaddExternBranchCand(scip, var, score::Cdouble, solval::Cdouble) +function SCIPaddExternBranchCand(scip, var, score, solval) ccall((:SCIPaddExternBranchCand, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, score, solval) end @@ -146,27 +146,27 @@ function SCIPgetNPrioPseudoBranchImpls(scip) ccall((:SCIPgetNPrioPseudoBranchImpls, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPgetBranchScore(scip, var, downgain::Cdouble, upgain::Cdouble) +function SCIPgetBranchScore(scip, var, downgain, upgain) ccall((:SCIPgetBranchScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, downgain, upgain) end -function SCIPgetBranchScoreMultiple(scip, var, nchildren::Cint, gains) +function SCIPgetBranchScoreMultiple(scip, var, nchildren, gains) ccall((:SCIPgetBranchScoreMultiple, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, nchildren, gains) end -function SCIPgetBranchingPoint(scip, var, suggestion::Cdouble) +function SCIPgetBranchingPoint(scip, var, suggestion) ccall((:SCIPgetBranchingPoint, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, suggestion) end -function SCIPcalcNodeselPriority(scip, var, branchdir::SCIP_BRANCHDIR, targetvalue::Cdouble) +function SCIPcalcNodeselPriority(scip, var, branchdir, targetvalue) ccall((:SCIPcalcNodeselPriority, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), scip, var, branchdir, targetvalue) end -function SCIPcalcChildEstimate(scip, var, targetvalue::Cdouble) +function SCIPcalcChildEstimate(scip, var, targetvalue) ccall((:SCIPcalcChildEstimate, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, targetvalue) end -function SCIPcreateChild(scip, node, nodeselprio::Cdouble, estimate::Cdouble) +function SCIPcreateChild(scip, node, nodeselprio, estimate) ccall((:SCIPcreateChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NODE}}, Cdouble, Cdouble), scip, node, nodeselprio, estimate) end @@ -174,15 +174,15 @@ function SCIPbranchVar(scip, var, downchild, eqchild, upchild) ccall((:SCIPbranchVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, downchild, eqchild, upchild) end -function SCIPbranchVarHole(scip, var, left::Cdouble, right::Cdouble, downchild, upchild) +function SCIPbranchVarHole(scip, var, left, right, downchild, upchild) ccall((:SCIPbranchVarHole, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, left, right, downchild, upchild) end -function SCIPbranchVarVal(scip, var, val::Cdouble, downchild, eqchild, upchild) +function SCIPbranchVarVal(scip, var, val, downchild, eqchild, upchild) ccall((:SCIPbranchVarVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, val, downchild, eqchild, upchild) end -function SCIPbranchVarValNary(scip, var, val::Cdouble, n::Cint, minwidth::Cdouble, widthfactor::Cdouble, nchildren) +function SCIPbranchVarValNary(scip, var, val, n, minwidth, widthfactor, nchildren) ccall((:SCIPbranchVarValNary, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cint, Cdouble, Cdouble, Ptr{Cint}), scip, var, val, n, minwidth, widthfactor, nchildren) end diff --git a/src/wrapper/scip_compr.jl b/src/wrapper/scip_compr.jl index 8873fa67..a0c7ce42 100644 --- a/src/wrapper/scip_compr.jl +++ b/src/wrapper/scip_compr.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_compr.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeCompr(scip, name, desc, priority::Cint, minnnodes::Cint, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) +function SCIPincludeCompr(scip, name, desc, priority, minnnodes, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) ccall((:SCIPincludeCompr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, name, desc, priority, minnnodes, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) end -function SCIPincludeComprBasic(scip, compr, name, desc, priority::Cint, minnnodes::Cint, comprexec, comprdata) +function SCIPincludeComprBasic(scip, compr, name, desc, priority, minnnodes, comprexec, comprdata) ccall((:SCIPincludeComprBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_COMPR}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, compr, name, desc, priority, minnnodes, comprexec, comprdata) end @@ -46,6 +46,6 @@ function SCIPgetNCompr(scip) ccall((:SCIPgetNCompr, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetComprPriority(scip, compr, priority::Cint) +function SCIPsetComprPriority(scip, compr, priority) ccall((:SCIPsetComprPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Cint), scip, compr, priority) end diff --git a/src/wrapper/scip_concurrent.jl b/src/wrapper/scip_concurrent.jl index 4c969f1c..adecb17a 100644 --- a/src/wrapper/scip_concurrent.jl +++ b/src/wrapper/scip_concurrent.jl @@ -1,8 +1,8 @@ # Julia wrapper for header: /usr/include/scip/scip_concurrent.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeConcsolverType(scip, name, prefpriodefault::Cdouble, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) +function SCIPincludeConcsolverType(scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) ccall((:SCIPincludeConcsolverType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONCSOLVERTYPEDATA}), scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) end diff --git a/src/wrapper/scip_conflict.jl b/src/wrapper/scip_conflict.jl index 27bf1cbe..ebcd0d2e 100644 --- a/src/wrapper/scip_conflict.jl +++ b/src/wrapper/scip_conflict.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_conflict.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeConflicthdlr(scip, name, desc, priority::Cint, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) +function SCIPincludeConflicthdlr(scip, name, desc, priority, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) ccall((:SCIPincludeConflicthdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, name, desc, priority, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) end -function SCIPincludeConflicthdlrBasic(scip, conflicthdlrptr, name, desc, priority::Cint, conflictexec, conflicthdlrdata) +function SCIPincludeConflicthdlrBasic(scip, conflicthdlrptr, name, desc, priority, conflictexec, conflicthdlrdata) ccall((:SCIPincludeConflicthdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONFLICTHDLR}}, Cstring, Cstring, Cint, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, conflicthdlrptr, name, desc, priority, conflictexec, conflicthdlrdata) end @@ -46,7 +46,7 @@ function SCIPgetNConflicthdlrs(scip) ccall((:SCIPgetNConflicthdlrs, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetConflicthdlrPriority(scip, conflicthdlr, priority::Cint) +function SCIPsetConflicthdlrPriority(scip, conflicthdlr, priority) ccall((:SCIPsetConflicthdlrPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Cint), scip, conflicthdlr, priority) end @@ -54,7 +54,7 @@ function SCIPisConflictAnalysisApplicable(scip) ccall((:SCIPisConflictAnalysisApplicable, libscip), UInt32, (Ptr{SCIP},), scip) end -function SCIPinitConflictAnalysis(scip, conftype::SCIP_CONFTYPE, iscutoffinvolved::UInt32) +function SCIPinitConflictAnalysis(scip, conftype, iscutoffinvolved) ccall((:SCIPinitConflictAnalysis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_CONFTYPE, UInt32), scip, conftype, iscutoffinvolved) end @@ -62,7 +62,7 @@ function SCIPaddConflictLb(scip, var, bdchgidx) ccall((:SCIPaddConflictLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) end -function SCIPaddConflictRelaxedLb(scip, var, bdchgidx, relaxedlb::Cdouble) +function SCIPaddConflictRelaxedLb(scip, var, bdchgidx, relaxedlb) ccall((:SCIPaddConflictRelaxedLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedlb) end @@ -70,15 +70,15 @@ function SCIPaddConflictUb(scip, var, bdchgidx) ccall((:SCIPaddConflictUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) end -function SCIPaddConflictRelaxedUb(scip, var, bdchgidx, relaxedub::Cdouble) +function SCIPaddConflictRelaxedUb(scip, var, bdchgidx, relaxedub) ccall((:SCIPaddConflictRelaxedUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedub) end -function SCIPaddConflictBd(scip, var, boundtype::SCIP_BOUNDTYPE, bdchgidx) +function SCIPaddConflictBd(scip, var, boundtype, bdchgidx) ccall((:SCIPaddConflictBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}), scip, var, boundtype, bdchgidx) end -function SCIPaddConflictRelaxedBd(scip, var, boundtype::SCIP_BOUNDTYPE, bdchgidx, relaxedbd::Cdouble) +function SCIPaddConflictRelaxedBd(scip, var, boundtype, bdchgidx, relaxedbd) ccall((:SCIPaddConflictRelaxedBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, boundtype, bdchgidx, relaxedbd) end @@ -86,7 +86,7 @@ function SCIPaddConflictBinvar(scip, var) ccall((:SCIPaddConflictBinvar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPisConflictVarUsed(scip, var, boundtype::SCIP_BOUNDTYPE, bdchgidx, used) +function SCIPisConflictVarUsed(scip, var, boundtype, bdchgidx, used) ccall((:SCIPisConflictVarUsed, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Ptr{UInt32}), scip, var, boundtype, bdchgidx, used) end @@ -98,7 +98,7 @@ function SCIPgetConflictVarUb(scip, var) ccall((:SCIPgetConflictVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPanalyzeConflict(scip, validdepth::Cint, success) +function SCIPanalyzeConflict(scip, validdepth, success) ccall((:SCIPanalyzeConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}), scip, validdepth, success) end diff --git a/src/wrapper/scip_cons.jl b/src/wrapper/scip_cons.jl index 74b3badc..8b69a0ff 100644 --- a/src/wrapper/scip_cons.jl +++ b/src/wrapper/scip_cons.jl @@ -1,20 +1,20 @@ # Julia wrapper for header: /usr/include/scip/scip_cons.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeConshdlr(scip, name, desc, sepapriority::Cint, enfopriority::Cint, chckpriority::Cint, sepafreq::Cint, propfreq::Cint, eagerfreq::Cint, maxprerounds::Cint, delaysepa::UInt32, delayprop::UInt32, needscons::UInt32, proptiming::SCIP_PROPTIMING, presoltiming::SCIP_PRESOLTIMING, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol, consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, conshdlrdata) +function SCIPincludeConshdlr(scip, name, desc, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol, consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, conshdlrdata) ccall((:SCIPincludeConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cint, Cint, Cint, Cint, Cint, UInt32, UInt32, UInt32, SCIP_PROPTIMING, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONSHDLRDATA}), scip, name, desc, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol, consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, conshdlrdata) end -function SCIPincludeConshdlrBasic(scip, conshdlrptr, name, desc, enfopriority::Cint, chckpriority::Cint, eagerfreq::Cint, needscons::UInt32, consenfolp, consenfops, conscheck, conslock, conshdlrdata) +function SCIPincludeConshdlrBasic(scip, conshdlrptr, name, desc, enfopriority, chckpriority, eagerfreq, needscons, consenfolp, consenfops, conscheck, conslock, conshdlrdata) ccall((:SCIPincludeConshdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONSHDLR}}, Cstring, Cstring, Cint, Cint, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONSHDLRDATA}), scip, conshdlrptr, name, desc, enfopriority, chckpriority, eagerfreq, needscons, consenfolp, consenfops, conscheck, conslock, conshdlrdata) end -function SCIPsetConshdlrSepa(scip, conshdlr, conssepalp, conssepasol, sepafreq::Cint, sepapriority::Cint, delaysepa::UInt32) +function SCIPsetConshdlrSepa(scip, conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) ccall((:SCIPsetConshdlrSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, UInt32), scip, conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) end -function SCIPsetConshdlrProp(scip, conshdlr, consprop, propfreq::Cint, delayprop::UInt32, proptiming::SCIP_PROPTIMING) +function SCIPsetConshdlrProp(scip, conshdlr, consprop, propfreq, delayprop, proptiming) ccall((:SCIPsetConshdlrProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, UInt32, SCIP_PROPTIMING), scip, conshdlr, consprop, propfreq, delayprop, proptiming) end @@ -54,7 +54,7 @@ function SCIPsetConshdlrExitpre(scip, conshdlr, consexitpre) ccall((:SCIPsetConshdlrExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitpre) end -function SCIPsetConshdlrPresol(scip, conshdlr, conspresol, maxprerounds::Cint, presoltiming::SCIP_PRESOLTIMING) +function SCIPsetConshdlrPresol(scip, conshdlr, conspresol, maxprerounds, presoltiming) ccall((:SCIPsetConshdlrPresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, SCIP_PRESOLTIMING), scip, conshdlr, conspresol, maxprerounds, presoltiming) end @@ -126,11 +126,11 @@ function SCIPgetNConshdlrs(scip) ccall((:SCIPgetNConshdlrs, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPcreateCons(scip, cons, name, conshdlr, consdata, initial::UInt32, separate::UInt32, enforce::UInt32, check::UInt32, propagate::UInt32, _local::UInt32, modifiable::UInt32, dynamic::UInt32, removable::UInt32, stickingatnode::UInt32) +function SCIPcreateCons(scip, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) ccall((:SCIPcreateCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONSDATA}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) end -function SCIPparseCons(scip, cons, str, initial::UInt32, separate::UInt32, enforce::UInt32, check::UInt32, propagate::UInt32, _local::UInt32, modifiable::UInt32, dynamic::UInt32, removable::UInt32, stickingatnode::UInt32, success) +function SCIPparseCons(scip, cons, str, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, success) ccall((:SCIPparseCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Cstring, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, cons, str, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, success) end @@ -146,43 +146,43 @@ function SCIPchgConsName(scip, cons, name) ccall((:SCIPchgConsName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cstring), scip, cons, name) end -function SCIPsetConsInitial(scip, cons, initial::UInt32) +function SCIPsetConsInitial(scip, cons, initial) ccall((:SCIPsetConsInitial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, initial) end -function SCIPsetConsSeparated(scip, cons, separate::UInt32) +function SCIPsetConsSeparated(scip, cons, separate) ccall((:SCIPsetConsSeparated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, separate) end -function SCIPsetConsEnforced(scip, cons, enforce::UInt32) +function SCIPsetConsEnforced(scip, cons, enforce) ccall((:SCIPsetConsEnforced, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, enforce) end -function SCIPsetConsChecked(scip, cons, check::UInt32) +function SCIPsetConsChecked(scip, cons, check) ccall((:SCIPsetConsChecked, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, check) end -function SCIPsetConsPropagated(scip, cons, propagate::UInt32) +function SCIPsetConsPropagated(scip, cons, propagate) ccall((:SCIPsetConsPropagated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, propagate) end -function SCIPsetConsLocal(scip, cons, _local::UInt32) +function SCIPsetConsLocal(scip, cons, _local) ccall((:SCIPsetConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, _local) end -function SCIPsetConsModifiable(scip, cons, modifiable::UInt32) +function SCIPsetConsModifiable(scip, cons, modifiable) ccall((:SCIPsetConsModifiable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, modifiable) end -function SCIPsetConsDynamic(scip, cons, dynamic::UInt32) +function SCIPsetConsDynamic(scip, cons, dynamic) ccall((:SCIPsetConsDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, dynamic) end -function SCIPsetConsRemovable(scip, cons, removable::UInt32) +function SCIPsetConsRemovable(scip, cons, removable) ccall((:SCIPsetConsRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, removable) end -function SCIPsetConsStickingAtNode(scip, cons, stickingatnode::UInt32) +function SCIPsetConsStickingAtNode(scip, cons, stickingatnode) ccall((:SCIPsetConsStickingAtNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, stickingatnode) end @@ -194,7 +194,7 @@ function SCIPtransformCons(scip, cons, transcons) ccall((:SCIPtransformCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) end -function SCIPtransformConss(scip, nconss::Cint, conss, transconss) +function SCIPtransformConss(scip, nconss, conss, transconss) ccall((:SCIPtransformConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) end @@ -202,11 +202,11 @@ function SCIPgetTransformedCons(scip, cons, transcons) ccall((:SCIPgetTransformedCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) end -function SCIPgetTransformedConss(scip, nconss::Cint, conss, transconss) +function SCIPgetTransformedConss(scip, nconss, conss, transconss) ccall((:SCIPgetTransformedConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) end -function SCIPaddConsAge(scip, cons, deltaage::Cdouble) +function SCIPaddConsAge(scip, cons, deltaage) ccall((:SCIPaddConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, deltaage) end @@ -250,27 +250,27 @@ function SCIPunmarkConsPropagate(scip, cons) ccall((:SCIPunmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPaddConsLocksType(scip, cons, locktype::SCIP_LOCKTYPE, nlockspos::Cint, nlocksneg::Cint) +function SCIPaddConsLocksType(scip, cons, locktype, nlockspos, nlocksneg) ccall((:SCIPaddConsLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_LOCKTYPE, Cint, Cint), scip, cons, locktype, nlockspos, nlocksneg) end -function SCIPaddConsLocks(scip, cons, nlockspos::Cint, nlocksneg::Cint) +function SCIPaddConsLocks(scip, cons, nlockspos, nlocksneg) ccall((:SCIPaddConsLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cint, Cint), scip, cons, nlockspos, nlocksneg) end -function SCIPcheckCons(scip, cons, sol, checkintegrality::UInt32, checklprows::UInt32, printreason::UInt32, result) +function SCIPcheckCons(scip, cons, sol, checkintegrality, checklprows, printreason, result) ccall((:SCIPcheckCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, Ptr{SCIP_RESULT}), scip, cons, sol, checkintegrality, checklprows, printreason, result) end -function SCIPenfopsCons(scip, cons, solinfeasible::UInt32, objinfeasible::UInt32, result) +function SCIPenfopsCons(scip, cons, solinfeasible, objinfeasible, result) ccall((:SCIPenfopsCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32, UInt32, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, objinfeasible, result) end -function SCIPenfolpCons(scip, cons, solinfeasible::UInt32, result) +function SCIPenfolpCons(scip, cons, solinfeasible, result) ccall((:SCIPenfolpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, result) end -function SCIPenforelaxCons(scip, cons, sol, solinfeasible::UInt32, result) +function SCIPenforelaxCons(scip, cons, sol, solinfeasible, result) ccall((:SCIPenforelaxCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, UInt32, Ptr{SCIP_RESULT}), scip, cons, sol, solinfeasible, result) end @@ -286,15 +286,15 @@ function SCIPsepasolCons(scip, cons, sol, result) ccall((:SCIPsepasolCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cons, sol, result) end -function SCIPpropCons(scip, cons, proptiming::SCIP_PROPTIMING, result) +function SCIPpropCons(scip, cons, proptiming, result) ccall((:SCIPpropCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_PROPTIMING, Ptr{SCIP_RESULT}), scip, cons, proptiming, result) end -function SCIPrespropCons(scip, cons, infervar, inferinfo::Cint, boundtype::SCIP_BOUNDTYPE, bdchgidx, relaxedbd::Cdouble, result) +function SCIPrespropCons(scip, cons, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, result) ccall((:SCIPrespropCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cint, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble, Ptr{SCIP_RESULT}), scip, cons, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, result) end -function SCIPpresolCons(scip, cons, nrounds::Cint, presoltiming::SCIP_PRESOLTIMING, nnewfixedvars::Cint, nnewaggrvars::Cint, nnewchgvartypes::Cint, nnewchgbds::Cint, nnewholes::Cint, nnewdelconss::Cint, nnewaddconss::Cint, nnewupgdconss::Cint, nnewchgcoefs::Cint, nnewchgsides::Cint, nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) +function SCIPpresolCons(scip, cons, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) ccall((:SCIPpresolCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cint, SCIP_PRESOLTIMING, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{SCIP_RESULT}), scip, cons, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) end @@ -310,7 +310,7 @@ function SCIPprintCons(scip, cons, file) ccall((:SCIPprintCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{FILE}), scip, cons, file) end -function SCIPgetConsVars(scip, cons, vars, varssize::Cint, success) +function SCIPgetConsVars(scip, cons, vars, varssize, success) ccall((:SCIPgetConsVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{UInt32}), scip, cons, vars, varssize, success) end diff --git a/src/wrapper/scip_copy.jl b/src/wrapper/scip_copy.jl index 5f659d3f..c62c85a5 100644 --- a/src/wrapper/scip_copy.jl +++ b/src/wrapper/scip_copy.jl @@ -1,8 +1,8 @@ # Julia wrapper for header: /usr/include/scip/scip_copy.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPcopyPlugins(sourcescip, targetscip, copyreaders::UInt32, copypricers::UInt32, copyconshdlrs::UInt32, copyconflicthdlrs::UInt32, copypresolvers::UInt32, copyrelaxators::UInt32, copyseparators::UInt32, copypropagators::UInt32, copyheuristics::UInt32, copyeventhdlrs::UInt32, copynodeselectors::UInt32, copybranchrules::UInt32, copydisplays::UInt32, copydialogs::UInt32, copytables::UInt32, copynlpis::UInt32, passmessagehdlr::UInt32, valid) +function SCIPcopyPlugins(sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copydisplays, copydialogs, copytables, copynlpis, passmessagehdlr, valid) ccall((:SCIPcopyPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copydisplays, copydialogs, copytables, copynlpis, passmessagehdlr, valid) end @@ -10,7 +10,7 @@ function SCIPcopyBenders(sourcescip, targetscip, varmap, valid) ccall((:SCIPcopyBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{UInt32}), sourcescip, targetscip, varmap, valid) end -function SCIPcopyProb(sourcescip, targetscip, varmap, consmap, _global::UInt32, name) +function SCIPcopyProb(sourcescip, targetscip, varmap, consmap, _global, name) ccall((:SCIPcopyProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Cstring), sourcescip, targetscip, varmap, consmap, _global, name) end @@ -26,47 +26,47 @@ function SCIPisConsCompressionEnabled(scip) ccall((:SCIPisConsCompressionEnabled, libscip), UInt32, (Ptr{SCIP},), scip) end -function SCIPgetVarCopy(sourcescip, targetscip, sourcevar, targetvar, varmap, consmap, _global::UInt32, success) +function SCIPgetVarCopy(sourcescip, targetscip, sourcevar, targetvar, varmap, consmap, _global, success) ccall((:SCIPgetVarCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}), sourcescip, targetscip, sourcevar, targetvar, varmap, consmap, _global, success) end -function SCIPcopyVars(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars::Cint, _global::UInt32) +function SCIPcopyVars(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars, _global) ccall((:SCIPcopyVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars, _global) end -function SCIPcopyOrigVars(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars::Cint) +function SCIPcopyOrigVars(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars) ccall((:SCIPcopyOrigVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars) end -function SCIPmergeVariableStatistics(sourcescip, targetscip, sourcevars, targetvars, nvars::Cint) +function SCIPmergeVariableStatistics(sourcescip, targetscip, sourcevars, targetvars, nvars) ccall((:SCIPmergeVariableStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint), sourcescip, targetscip, sourcevars, targetvars, nvars) end -function SCIPgetConsCopy(sourcescip, targetscip, sourcecons, targetcons, sourceconshdlr, varmap, consmap, name, initial::UInt32, separate::UInt32, enforce::UInt32, check::UInt32, propagate::UInt32, _local::UInt32, modifiable::UInt32, dynamic::UInt32, removable::UInt32, stickingatnode::UInt32, _global::UInt32, valid) +function SCIPgetConsCopy(sourcescip, targetscip, sourcecons, targetcons, sourceconshdlr, varmap, consmap, name, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) ccall((:SCIPgetConsCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, sourcecons, targetcons, sourceconshdlr, varmap, consmap, name, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) end -function SCIPcopyConss(sourcescip, targetscip, varmap, consmap, _global::UInt32, enablepricing::UInt32, valid) +function SCIPcopyConss(sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) ccall((:SCIPcopyConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) end -function SCIPcopyOrigConss(sourcescip, targetscip, varmap, consmap, enablepricing::UInt32, valid) +function SCIPcopyOrigConss(sourcescip, targetscip, varmap, consmap, enablepricing, valid) ccall((:SCIPcopyOrigConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, enablepricing, valid) end -function SCIPconvertCutsToConss(scip, varmap, consmap, _global::UInt32, ncutsadded) +function SCIPconvertCutsToConss(scip, varmap, consmap, _global, ncutsadded) ccall((:SCIPconvertCutsToConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{Cint}), scip, varmap, consmap, _global, ncutsadded) end -function SCIPcopyCuts(sourcescip, targetscip, varmap, consmap, _global::UInt32, ncutsadded) +function SCIPcopyCuts(sourcescip, targetscip, varmap, consmap, _global, ncutsadded) ccall((:SCIPcopyCuts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, ncutsadded) end -function SCIPcopyConflicts(sourcescip, targetscip, varmap, consmap, _global::UInt32, enablepricing::UInt32, valid) +function SCIPcopyConflicts(sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) ccall((:SCIPcopyConflicts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) end -function SCIPcopyImplicationsCliques(sourcescip, targetscip, varmap, consmap, _global::UInt32, infeasible, nbdchgs, ncopied) +function SCIPcopyImplicationsCliques(sourcescip, targetscip, varmap, consmap, _global, infeasible, nbdchgs, ncopied) ccall((:SCIPcopyImplicationsCliques, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}, Ptr{Cint}, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, infeasible, nbdchgs, ncopied) end @@ -78,23 +78,23 @@ function SCIPgetSubscipDepth(scip) ccall((:SCIPgetSubscipDepth, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetSubscipDepth(scip, newdepth::Cint) +function SCIPsetSubscipDepth(scip, newdepth) ccall((:SCIPsetSubscipDepth, libscip), Cvoid, (Ptr{SCIP}, Cint), scip, newdepth) end -function SCIPcopy(sourcescip, targetscip, varmap, consmap, suffix, _global::UInt32, enablepricing::UInt32, passmessagehdlr::UInt32, valid) +function SCIPcopy(sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, passmessagehdlr, valid) ccall((:SCIPcopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, passmessagehdlr, valid) end -function SCIPcopyConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars::Cint, _global::UInt32, enablepricing::UInt32, passmessagehdlr::UInt32, valid) +function SCIPcopyConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, passmessagehdlr, valid) ccall((:SCIPcopyConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, passmessagehdlr, valid) end -function SCIPcopyOrig(sourcescip, targetscip, varmap, consmap, suffix, enablepricing::UInt32, passmessagehdlr::UInt32, valid) +function SCIPcopyOrig(sourcescip, targetscip, varmap, consmap, suffix, enablepricing, passmessagehdlr, valid) ccall((:SCIPcopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, enablepricing, passmessagehdlr, valid) end -function SCIPcopyOrigConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars::Cint, enablepricing::UInt32, passmessagehdlr::UInt32, valid) +function SCIPcopyOrigConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, passmessagehdlr, valid) ccall((:SCIPcopyOrigConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, passmessagehdlr, valid) end diff --git a/src/wrapper/scip_cut.jl b/src/wrapper/scip_cut.jl index 41b1e8d1..b910c1cd 100644 --- a/src/wrapper/scip_cut.jl +++ b/src/wrapper/scip_cut.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_cut.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPgetCutEfficacy(scip, sol, cut) @@ -10,11 +10,11 @@ function SCIPisCutEfficacious(scip, sol, cut) ccall((:SCIPisCutEfficacious, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) end -function SCIPisEfficacious(scip, efficacy::Cdouble) +function SCIPisEfficacious(scip, efficacy) ccall((:SCIPisEfficacious, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, efficacy) end -function SCIPgetVectorEfficacyNorm(scip, vals, nvals::Cint) +function SCIPgetVectorEfficacyNorm(scip, vals, nvals) ccall((:SCIPgetVectorEfficacyNorm, libscip), Cdouble, (Ptr{SCIP}, Ptr{Cdouble}, Cint), scip, vals, nvals) end @@ -22,11 +22,11 @@ function SCIPisCutApplicable(scip, cut) ccall((:SCIPisCutApplicable, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, cut) end -function SCIPaddCut(scip, sol, cut, forcecut::UInt32, infeasible) +function SCIPaddCut(scip, sol, cut, forcecut, infeasible) ccall((:SCIPaddCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}, UInt32, Ptr{UInt32}), scip, sol, cut, forcecut, infeasible) end -function SCIPaddRow(scip, row, forcecut::UInt32, infeasible) +function SCIPaddRow(scip, row, forcecut, infeasible) ccall((:SCIPaddRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, UInt32, Ptr{UInt32}), scip, row, forcecut, infeasible) end @@ -54,7 +54,7 @@ function SCIPgetGlobalCutpool(scip) ccall((:SCIPgetGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP},), scip) end -function SCIPcreateCutpool(scip, cutpool, agelimit::Cint) +function SCIPcreateCutpool(scip, cutpool, agelimit) ccall((:SCIPcreateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}, Cint), scip, cutpool, agelimit) end @@ -102,7 +102,7 @@ function SCIPgetDelayedGlobalCutpool(scip) ccall((:SCIPgetDelayedGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP},), scip) end -function SCIPseparateSol(scip, sol, pretendroot::UInt32, allowlocal::UInt32, onlydelayed::UInt32, delayed, cutoff) +function SCIPseparateSol(scip, sol, pretendroot, allowlocal, onlydelayed, delayed, cutoff) ccall((:SCIPseparateSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, sol, pretendroot, allowlocal, onlydelayed, delayed, cutoff) end diff --git a/src/wrapper/scip_datastructures.jl b/src/wrapper/scip_datastructures.jl index 87cb9c18..ce451ee7 100644 --- a/src/wrapper/scip_datastructures.jl +++ b/src/wrapper/scip_datastructures.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_datastructures.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPcreateRealarray(scip, realarray) @@ -10,7 +10,7 @@ function SCIPfreeRealarray(scip, realarray) ccall((:SCIPfreeRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) end -function SCIPextendRealarray(scip, realarray, minidx::Cint, maxidx::Cint) +function SCIPextendRealarray(scip, realarray, minidx, maxidx) ccall((:SCIPextendRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cint), scip, realarray, minidx, maxidx) end @@ -18,15 +18,15 @@ function SCIPclearRealarray(scip, realarray) ccall((:SCIPclearRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) end -function SCIPgetRealarrayVal(scip, realarray, idx::Cint) +function SCIPgetRealarrayVal(scip, realarray, idx) ccall((:SCIPgetRealarrayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint), scip, realarray, idx) end -function SCIPsetRealarrayVal(scip, realarray, idx::Cint, val::Cdouble) +function SCIPsetRealarrayVal(scip, realarray, idx, val) ccall((:SCIPsetRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, val) end -function SCIPincRealarrayVal(scip, realarray, idx::Cint, incval::Cdouble) +function SCIPincRealarrayVal(scip, realarray, idx, incval) ccall((:SCIPincRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, incval) end @@ -46,7 +46,7 @@ function SCIPfreeIntarray(scip, intarray) ccall((:SCIPfreeIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) end -function SCIPextendIntarray(scip, intarray, minidx::Cint, maxidx::Cint) +function SCIPextendIntarray(scip, intarray, minidx, maxidx) ccall((:SCIPextendIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, minidx, maxidx) end @@ -54,15 +54,15 @@ function SCIPclearIntarray(scip, intarray) ccall((:SCIPclearIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) end -function SCIPgetIntarrayVal(scip, intarray, idx::Cint) +function SCIPgetIntarrayVal(scip, intarray, idx) ccall((:SCIPgetIntarrayVal, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint), scip, intarray, idx) end -function SCIPsetIntarrayVal(scip, intarray, idx::Cint, val::Cint) +function SCIPsetIntarrayVal(scip, intarray, idx, val) ccall((:SCIPsetIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, val) end -function SCIPincIntarrayVal(scip, intarray, idx::Cint, incval::Cint) +function SCIPincIntarrayVal(scip, intarray, idx, incval) ccall((:SCIPincIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, incval) end @@ -82,7 +82,7 @@ function SCIPfreeBoolarray(scip, boolarray) ccall((:SCIPfreeBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) end -function SCIPextendBoolarray(scip, boolarray, minidx::Cint, maxidx::Cint) +function SCIPextendBoolarray(scip, boolarray, minidx, maxidx) ccall((:SCIPextendBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cint), scip, boolarray, minidx, maxidx) end @@ -90,11 +90,11 @@ function SCIPclearBoolarray(scip, boolarray) ccall((:SCIPclearBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) end -function SCIPgetBoolarrayVal(scip, boolarray, idx::Cint) +function SCIPgetBoolarrayVal(scip, boolarray, idx) ccall((:SCIPgetBoolarrayVal, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint), scip, boolarray, idx) end -function SCIPsetBoolarrayVal(scip, boolarray, idx::Cint, val::UInt32) +function SCIPsetBoolarrayVal(scip, boolarray, idx, val) ccall((:SCIPsetBoolarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, UInt32), scip, boolarray, idx, val) end @@ -114,7 +114,7 @@ function SCIPfreePtrarray(scip, ptrarray) ccall((:SCIPfreePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) end -function SCIPextendPtrarray(scip, ptrarray, minidx::Cint, maxidx::Cint) +function SCIPextendPtrarray(scip, ptrarray, minidx, maxidx) ccall((:SCIPextendPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Cint), scip, ptrarray, minidx, maxidx) end @@ -122,11 +122,11 @@ function SCIPclearPtrarray(scip, ptrarray) ccall((:SCIPclearPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) end -function SCIPgetPtrarrayVal(scip, ptrarray, idx::Cint) +function SCIPgetPtrarrayVal(scip, ptrarray, idx) ccall((:SCIPgetPtrarrayVal, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint), scip, ptrarray, idx) end -function SCIPsetPtrarrayVal(scip, ptrarray, idx::Cint, val) +function SCIPsetPtrarrayVal(scip, ptrarray, idx, val) ccall((:SCIPsetPtrarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Ptr{Cvoid}), scip, ptrarray, idx, val) end @@ -138,7 +138,7 @@ function SCIPgetPtrarrayMaxIdx(scip, ptrarray) ccall((:SCIPgetPtrarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) end -function SCIPcreateDisjointset(scip, djset, ncomponents::Cint) +function SCIPcreateDisjointset(scip, djset, ncomponents) ccall((:SCIPcreateDisjointset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}, Cint), scip, djset, ncomponents) end @@ -146,7 +146,7 @@ function SCIPfreeDisjointset(scip, djset) ccall((:SCIPfreeDisjointset, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}), scip, djset) end -function SCIPcreateDigraph(scip, digraph, nnodes::Cint) +function SCIPcreateDigraph(scip, digraph, nnodes) ccall((:SCIPcreateDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Cint), scip, digraph, nnodes) end diff --git a/src/wrapper/scip_debug.jl b/src/wrapper/scip_debug.jl index f14abed2..7e4caa74 100644 --- a/src/wrapper/scip_debug.jl +++ b/src/wrapper/scip_debug.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_debug.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPenableDebugSol(scip) diff --git a/src/wrapper/scip_dialog.jl b/src/wrapper/scip_dialog.jl index fbd88a9e..351b62dc 100644 --- a/src/wrapper/scip_dialog.jl +++ b/src/wrapper/scip_dialog.jl @@ -1,8 +1,8 @@ # Julia wrapper for header: /usr/include/scip/scip_dialog.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeDialog(scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu::UInt32, dialogdata) +function SCIPincludeDialog(scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu, dialogdata) ccall((:SCIPincludeDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cstring, Cstring, UInt32, Ptr{SCIP_DIALOGDATA}), scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu, dialogdata) end diff --git a/src/wrapper/scip_disp.jl b/src/wrapper/scip_disp.jl index e7ac4a89..f7b1a2f2 100644 --- a/src/wrapper/scip_disp.jl +++ b/src/wrapper/scip_disp.jl @@ -1,8 +1,8 @@ # Julia wrapper for header: /usr/include/scip/scip_disp.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeDisp(scip, name, desc, header, dispstatus::SCIP_DISPSTATUS, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width::Cint, priority::Cint, position::Cint, stripline::UInt32) +function SCIPincludeDisp(scip, name, desc, header, dispstatus, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width, priority, position, stripline) ccall((:SCIPincludeDisp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cstring, SCIP_DISPSTATUS, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_DISPDATA}, Cint, Cint, Cint, UInt32), scip, name, desc, header, dispstatus, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width, priority, position, stripline) end @@ -22,6 +22,6 @@ function SCIPautoselectDisps(scip) ccall((:SCIPautoselectDisps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPchgDispMode(disp, mode::SCIP_DISPMODE) +function SCIPchgDispMode(disp, mode) ccall((:SCIPchgDispMode, libscip), Cvoid, (Ptr{SCIP_DISP}, SCIP_DISPMODE), disp, mode) end diff --git a/src/wrapper/scip_event.jl b/src/wrapper/scip_event.jl index 27272af1..97d0877a 100644 --- a/src/wrapper/scip_event.jl +++ b/src/wrapper/scip_event.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_event.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPincludeEventhdlr(scip, name, desc, eventcopy, eventfree, eventinit, eventexit, eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata) @@ -50,26 +50,26 @@ function SCIPgetNEventhdlrs(scip) ccall((:SCIPgetNEventhdlrs, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPcatchEvent(scip, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos) +function SCIPcatchEvent(scip, eventtype, eventhdlr, eventdata, filterpos) ccall((:SCIPcatchEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, eventtype, eventhdlr, eventdata, filterpos) end -function SCIPdropEvent(scip, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos::Cint) +function SCIPdropEvent(scip, eventtype, eventhdlr, eventdata, filterpos) ccall((:SCIPdropEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, eventtype, eventhdlr, eventdata, filterpos) end -function SCIPcatchVarEvent(scip, var, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos) +function SCIPcatchVarEvent(scip, var, eventtype, eventhdlr, eventdata, filterpos) ccall((:SCIPcatchVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, var, eventtype, eventhdlr, eventdata, filterpos) end -function SCIPdropVarEvent(scip, var, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos::Cint) +function SCIPdropVarEvent(scip, var, eventtype, eventhdlr, eventdata, filterpos) ccall((:SCIPdropVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, var, eventtype, eventhdlr, eventdata, filterpos) end -function SCIPcatchRowEvent(scip, row, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos) +function SCIPcatchRowEvent(scip, row, eventtype, eventhdlr, eventdata, filterpos) ccall((:SCIPcatchRowEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, row, eventtype, eventhdlr, eventdata, filterpos) end -function SCIPdropRowEvent(scip, row, eventtype::SCIP_EVENTTYPE, eventhdlr, eventdata, filterpos::Cint) +function SCIPdropRowEvent(scip, row, eventtype, eventhdlr, eventdata, filterpos) ccall((:SCIPdropRowEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, row, eventtype, eventhdlr, eventdata, filterpos) end diff --git a/src/wrapper/scip_expr.jl b/src/wrapper/scip_expr.jl index adc33479..35df1e76 100644 --- a/src/wrapper/scip_expr.jl +++ b/src/wrapper/scip_expr.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_expr.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPgetExprtreeTransformedVars(scip, tree) @@ -10,10 +10,10 @@ function SCIPevalExprtreeSol(scip, tree, sol, val) ccall((:SCIPevalExprtreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, tree, sol, val) end -function SCIPevalExprtreeGlobalBounds(scip, tree, infinity::Cdouble, val) +function SCIPevalExprtreeGlobalBounds(scip, tree, infinity, val) ccall((:SCIPevalExprtreeGlobalBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Cdouble, Ptr{Cint}), scip, tree, infinity, val) end -function SCIPevalExprtreeLocalBounds(scip, tree, infinity::Cdouble, val) +function SCIPevalExprtreeLocalBounds(scip, tree, infinity, val) ccall((:SCIPevalExprtreeLocalBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Cdouble, Ptr{Cint}), scip, tree, infinity, val) end diff --git a/src/wrapper/scip_general.jl b/src/wrapper/scip_general.jl index aeacb5a1..aa1cb39b 100644 --- a/src/wrapper/scip_general.jl +++ b/src/wrapper/scip_general.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_general.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPversion() @@ -30,7 +30,7 @@ function SCIPprintBuildOptions(scip, file) ccall((:SCIPprintBuildOptions, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) end -function SCIPprintError(retcode::SCIP_RETCODE) +function SCIPprintError(retcode) ccall((:SCIPprintError, libscip), Cvoid, (SCIP_RETCODE,), retcode) end diff --git a/src/wrapper/scip_heur.jl b/src/wrapper/scip_heur.jl index b45a4b8e..a88a2fc2 100644 --- a/src/wrapper/scip_heur.jl +++ b/src/wrapper/scip_heur.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_heur.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeHeur(scip, name, desc, dispchar::UInt8, priority::Cint, freq::Cint, freqofs::Cint, maxdepth::Cint, timingmask::SCIP_HEURTIMING, usessubscip::UInt32, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) +function SCIPincludeHeur(scip, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) ccall((:SCIPincludeHeur, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt8, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) end -function SCIPincludeHeurBasic(scip, heur, name, desc, dispchar::UInt8, priority::Cint, freq::Cint, freqofs::Cint, maxdepth::Cint, timingmask::SCIP_HEURTIMING, usessubscip::UInt32, heurexec, heurdata) +function SCIPincludeHeurBasic(scip, heur, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurexec, heurdata) ccall((:SCIPincludeHeurBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_HEUR}}, Cstring, Cstring, UInt8, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, UInt32, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, heur, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurexec, heurdata) end @@ -46,10 +46,10 @@ function SCIPgetNHeurs(scip) ccall((:SCIPgetNHeurs, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetHeurPriority(scip, heur, priority::Cint) +function SCIPsetHeurPriority(scip, heur, priority) ccall((:SCIPsetHeurPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Cint), scip, heur, priority) end -function SCIPcreateDiveset(scip, diveset, heur, name, minreldepth::Cdouble, maxreldepth::Cdouble, maxlpiterquot::Cdouble, maxdiveubquot::Cdouble, maxdiveavgquot::Cdouble, maxdiveubquotnosol::Cdouble, maxdiveavgquotnosol::Cdouble, lpresolvedomchgquot::Cdouble, lpsolvefreq::Cint, maxlpiterofs::Cint, initialseed::UInt32, backtrack::UInt32, onlylpbranchcands::UInt32, specificsos1score::UInt32, divesetgetscore) +function SCIPcreateDiveset(scip, diveset, heur, name, minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol, maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack, onlylpbranchcands, specificsos1score, divesetgetscore) ccall((:SCIPcreateDiveset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIVESET}}, Ptr{SCIP_HEUR}, Cstring, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}), scip, diveset, heur, name, minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol, maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack, onlylpbranchcands, specificsos1score, divesetgetscore) end diff --git a/src/wrapper/scip_lp.jl b/src/wrapper/scip_lp.jl index 27a18481..1f20174a 100644 --- a/src/wrapper/scip_lp.jl +++ b/src/wrapper/scip_lp.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_lp.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPhasCurrentNodeLP(scip) @@ -106,19 +106,19 @@ function SCIPgetLPBasisInd(scip, basisind) ccall((:SCIPgetLPBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, basisind) end -function SCIPgetLPBInvRow(scip, r::Cint, coefs, inds, ninds) +function SCIPgetLPBInvRow(scip, r, coefs, inds, ninds) ccall((:SCIPgetLPBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, coefs, inds, ninds) end -function SCIPgetLPBInvCol(scip, c::Cint, coefs, inds, ninds) +function SCIPgetLPBInvCol(scip, c, coefs, inds, ninds) ccall((:SCIPgetLPBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) end -function SCIPgetLPBInvARow(scip, r::Cint, binvrow, coefs, inds, ninds) +function SCIPgetLPBInvARow(scip, r, binvrow, coefs, inds, ninds) ccall((:SCIPgetLPBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, binvrow, coefs, inds, ninds) end -function SCIPgetLPBInvACol(scip, c::Cint, coefs, inds, ninds) +function SCIPgetLPBInvACol(scip, c, coefs, inds, ninds) ccall((:SCIPgetLPBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) end @@ -130,7 +130,7 @@ function SCIPwriteLP(scip, filename) ccall((:SCIPwriteLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) end -function SCIPwriteMIP(scip, filename, genericnames::UInt32, origobj::UInt32, lazyconss::UInt32) +function SCIPwriteMIP(scip, filename, genericnames, origobj, lazyconss) ccall((:SCIPwriteMIP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32, UInt32, UInt32), scip, filename, genericnames, origobj, lazyconss) end @@ -142,7 +142,7 @@ function SCIPprintLPSolutionQuality(scip, file) ccall((:SCIPprintLPSolutionQuality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) end -function SCIPcomputeLPRelIntPoint(scip, relaxrows::UInt32, inclobjcutoff::UInt32, timelimit::Cdouble, iterlimit::Cint, point) +function SCIPcomputeLPRelIntPoint(scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) ccall((:SCIPcomputeLPRelIntPoint, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, Cdouble, Cint, Ptr{Ptr{SCIP_SOL}}), scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) end @@ -158,35 +158,35 @@ function SCIPmarkColNotRemovableLocal(scip, col) ccall((:SCIPmarkColNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) end -function SCIPcreateRowCons(scip, row, conshdlr, name, len::Cint, cols, vals, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) +function SCIPcreateRowCons(scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) ccall((:SCIPcreateRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) end -function SCIPcreateRowSepa(scip, row, sepa, name, len::Cint, cols, vals, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) +function SCIPcreateRowSepa(scip, row, sepa, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) ccall((:SCIPcreateRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_SEPA}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, sepa, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) end -function SCIPcreateRowUnspec(scip, row, name, len::Cint, cols, vals, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) +function SCIPcreateRowUnspec(scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) ccall((:SCIPcreateRowUnspec, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) end -function SCIPcreateRow(scip, row, name, len::Cint, cols, vals, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) +function SCIPcreateRow(scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) ccall((:SCIPcreateRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) end -function SCIPcreateEmptyRowCons(scip, row, conshdlr, name, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) +function SCIPcreateEmptyRowCons(scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) ccall((:SCIPcreateEmptyRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) end -function SCIPcreateEmptyRowSepa(scip, row, sepa, name, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) +function SCIPcreateEmptyRowSepa(scip, row, sepa, name, lhs, rhs, _local, modifiable, removable) ccall((:SCIPcreateEmptyRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_SEPA}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, sepa, name, lhs, rhs, _local, modifiable, removable) end -function SCIPcreateEmptyRowUnspec(scip, row, name, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) +function SCIPcreateEmptyRowUnspec(scip, row, name, lhs, rhs, _local, modifiable, removable) ccall((:SCIPcreateEmptyRowUnspec, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, lhs, rhs, _local, modifiable, removable) end -function SCIPcreateEmptyRow(scip, row, name, lhs::Cdouble, rhs::Cdouble, _local::UInt32, modifiable::UInt32, removable::UInt32) +function SCIPcreateEmptyRow(scip, row, name, lhs, rhs, _local, modifiable, removable) ccall((:SCIPcreateEmptyRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, lhs, rhs, _local, modifiable, removable) end @@ -198,11 +198,11 @@ function SCIPreleaseRow(scip, row) ccall((:SCIPreleaseRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}), scip, row) end -function SCIPchgRowLhs(scip, row, lhs::Cdouble) +function SCIPchgRowLhs(scip, row, lhs) ccall((:SCIPchgRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, lhs) end -function SCIPchgRowRhs(scip, row, rhs::Cdouble) +function SCIPchgRowRhs(scip, row, rhs) ccall((:SCIPchgRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, rhs) end @@ -214,23 +214,23 @@ function SCIPflushRowExtensions(scip, row) ccall((:SCIPflushRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end -function SCIPaddVarToRow(scip, row, var, val::Cdouble) +function SCIPaddVarToRow(scip, row, var, val) ccall((:SCIPaddVarToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_VAR}, Cdouble), scip, row, var, val) end -function SCIPaddVarsToRow(scip, row, nvars::Cint, vars, vals) +function SCIPaddVarsToRow(scip, row, nvars, vars, vals) ccall((:SCIPaddVarsToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, row, nvars, vars, vals) end -function SCIPaddVarsToRowSameCoef(scip, row, nvars::Cint, vars, val::Cdouble) +function SCIPaddVarsToRowSameCoef(scip, row, nvars, vars, val) ccall((:SCIPaddVarsToRowSameCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Cdouble), scip, row, nvars, vars, val) end -function SCIPcalcRowIntegralScalar(scip, row, mindelta::Cdouble, maxdelta::Cdouble, maxdnom::Clonglong, maxscale::Cdouble, usecontvars::UInt32, intscalar, success) +function SCIPcalcRowIntegralScalar(scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) ccall((:SCIPcalcRowIntegralScalar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Clonglong, Cdouble, UInt32, Ptr{Cdouble}, Ptr{UInt32}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) end -function SCIPmakeRowIntegral(scip, row, mindelta::Cdouble, maxdelta::Cdouble, maxdnom::Clonglong, maxscale::Cdouble, usecontvars::UInt32, success) +function SCIPmakeRowIntegral(scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) ccall((:SCIPmakeRowIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Clonglong, Cdouble, UInt32, Ptr{UInt32}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) end @@ -314,19 +314,19 @@ function SCIPendDive(scip) ccall((:SCIPendDive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPchgCutoffboundDive(scip, newcutoffbound::Cdouble) +function SCIPchgCutoffboundDive(scip, newcutoffbound) ccall((:SCIPchgCutoffboundDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newcutoffbound) end -function SCIPchgVarObjDive(scip, var, newobj::Cdouble) +function SCIPchgVarObjDive(scip, var, newobj) ccall((:SCIPchgVarObjDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end -function SCIPchgVarLbDive(scip, var, newbound::Cdouble) +function SCIPchgVarLbDive(scip, var, newbound) ccall((:SCIPchgVarLbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end -function SCIPchgVarUbDive(scip, var, newbound::Cdouble) +function SCIPchgVarUbDive(scip, var, newbound) ccall((:SCIPchgVarUbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end @@ -334,11 +334,11 @@ function SCIPaddRowDive(scip, row) ccall((:SCIPaddRowDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end -function SCIPchgRowLhsDive(scip, row, newlhs::Cdouble) +function SCIPchgRowLhsDive(scip, row, newlhs) ccall((:SCIPchgRowLhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newlhs) end -function SCIPchgRowRhsDive(scip, row, newrhs::Cdouble) +function SCIPchgRowRhsDive(scip, row, newrhs) ccall((:SCIPchgRowRhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newrhs) end @@ -354,7 +354,7 @@ function SCIPgetVarUbDive(scip, var) ccall((:SCIPgetVarUbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPsolveDiveLP(scip, itlim::Cint, lperror, cutoff) +function SCIPsolveDiveLP(scip, itlim, lperror, cutoff) ccall((:SCIPsolveDiveLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, itlim, lperror, cutoff) end diff --git a/src/wrapper/scip_mem.jl b/src/wrapper/scip_mem.jl index 83f0696a..8528a740 100644 --- a/src/wrapper/scip_mem.jl +++ b/src/wrapper/scip_mem.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_mem.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPblkmem(scip) @@ -26,11 +26,11 @@ function SCIPgetMemExternEstim(scip) ccall((:SCIPgetMemExternEstim, libscip), Clonglong, (Ptr{SCIP},), scip) end -function SCIPcalcMemGrowSize(scip, num::Cint) +function SCIPcalcMemGrowSize(scip, num) ccall((:SCIPcalcMemGrowSize, libscip), Cint, (Ptr{SCIP}, Cint), scip, num) end -function SCIPensureBlockMemoryArray_call(scip, arrayptr, elemsize::Csize_t, arraysize, minsize::Cint) +function SCIPensureBlockMemoryArray_call(scip, arrayptr, elemsize, arraysize, minsize) ccall((:SCIPensureBlockMemoryArray_call, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cint}, Cint), scip, arrayptr, elemsize, arraysize, minsize) end diff --git a/src/wrapper/scip_message.jl b/src/wrapper/scip_message.jl index 66e5dac5..c7a1a149 100644 --- a/src/wrapper/scip_message.jl +++ b/src/wrapper/scip_message.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_message.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPsetMessagehdlr(scip, messagehdlr) @@ -14,7 +14,7 @@ function SCIPsetMessagehdlrLogfile(scip, filename) ccall((:SCIPsetMessagehdlrLogfile, libscip), Cvoid, (Ptr{SCIP}, Cstring), scip, filename) end -function SCIPsetMessagehdlrQuiet(scip, quiet::UInt32) +function SCIPsetMessagehdlrQuiet(scip, quiet) ccall((:SCIPsetMessagehdlrQuiet, libscip), Cvoid, (Ptr{SCIP}, UInt32), scip, quiet) end diff --git a/src/wrapper/scip_nlp.jl b/src/wrapper/scip_nlp.jl index 07cd6b35..d67615b5 100644 --- a/src/wrapper/scip_nlp.jl +++ b/src/wrapper/scip_nlp.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_nlp.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPincludeNlpi(scip, nlpi) @@ -18,7 +18,7 @@ function SCIPgetNNlpis(scip) ccall((:SCIPgetNNlpis, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetNlpiPriority(scip, nlpi, priority::Cint) +function SCIPsetNlpiPriority(scip, nlpi, priority) ccall((:SCIPsetNlpiPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Cint), scip, nlpi, priority) end @@ -118,27 +118,27 @@ function SCIPgetNLPFracVars(scip, fracvars, fracvarssol, fracvarsfrac, nfracvars ccall((:SCIPgetNLPFracVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}), scip, fracvars, fracvarssol, fracvarsfrac, nfracvars, npriofracvars) end -function SCIPgetNLPIntPar(scip, type::SCIP_NLPPARAM, ival) +function SCIPgetNLPIntPar(scip, type, ival) ccall((:SCIPgetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cint}), scip, type, ival) end -function SCIPsetNLPIntPar(scip, type::SCIP_NLPPARAM, ival::Cint) +function SCIPsetNLPIntPar(scip, type, ival) ccall((:SCIPsetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cint), scip, type, ival) end -function SCIPgetNLPRealPar(scip, type::SCIP_NLPPARAM, dval) +function SCIPgetNLPRealPar(scip, type, dval) ccall((:SCIPgetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cdouble}), scip, type, dval) end -function SCIPsetNLPRealPar(scip, type::SCIP_NLPPARAM, dval::Cdouble) +function SCIPsetNLPRealPar(scip, type, dval) ccall((:SCIPsetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cdouble), scip, type, dval) end -function SCIPgetNLPStringPar(scip, type::SCIP_NLPPARAM, sval) +function SCIPgetNLPStringPar(scip, type, sval) ccall((:SCIPgetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cstring}), scip, type, sval) end -function SCIPsetNLPStringPar(scip, type::SCIP_NLPPARAM, sval) +function SCIPsetNLPStringPar(scip, type, sval) ccall((:SCIPsetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cstring), scip, type, sval) end @@ -158,15 +158,15 @@ function SCIPendDiveNLP(scip) ccall((:SCIPendDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPchgVarObjDiveNLP(scip, var, coef::Cdouble) +function SCIPchgVarObjDiveNLP(scip, var, coef) ccall((:SCIPchgVarObjDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, coef) end -function SCIPchgVarBoundsDiveNLP(scip, var, lb::Cdouble, ub::Cdouble) +function SCIPchgVarBoundsDiveNLP(scip, var, lb, ub) ccall((:SCIPchgVarBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, lb, ub) end -function SCIPchgVarsBoundsDiveNLP(scip, nvars::Cint, vars, lbs, ubs) +function SCIPchgVarsBoundsDiveNLP(scip, nvars, vars, lbs, ubs) ccall((:SCIPchgVarsBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nvars, vars, lbs, ubs) end @@ -174,11 +174,11 @@ function SCIPsolveDiveNLP(scip) ccall((:SCIPsolveDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPcreateNlRow(scip, nlrow, name, constant::Cdouble, nlinvars::Cint, linvars, lincoefs, nquadvars::Cint, quadvars, nquadelems::Cint, quadelems, expression, lhs::Cdouble, rhs::Cdouble, curvature::SCIP_EXPRCURV) +function SCIPcreateNlRow(scip, nlrow, name, constant, nlinvars, linvars, lincoefs, nquadvars, quadvars, nquadelems, quadelems, expression, lhs, rhs, curvature) ccall((:SCIPcreateNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Cstring, Cdouble, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{SCIP_QUADELEM}, Ptr{SCIP_EXPRTREE}, Cdouble, Cdouble, SCIP_EXPRCURV), scip, nlrow, name, constant, nlinvars, linvars, lincoefs, nquadvars, quadvars, nquadelems, quadelems, expression, lhs, rhs, curvature) end -function SCIPcreateEmptyNlRow(scip, nlrow, name, lhs::Cdouble, rhs::Cdouble) +function SCIPcreateEmptyNlRow(scip, nlrow, name, lhs, rhs) ccall((:SCIPcreateEmptyNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Cstring, Cdouble, Cdouble), scip, nlrow, name, lhs, rhs) end @@ -194,27 +194,27 @@ function SCIPreleaseNlRow(scip, nlrow) ccall((:SCIPreleaseNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}), scip, nlrow) end -function SCIPchgNlRowLhs(scip, nlrow, lhs::Cdouble) +function SCIPchgNlRowLhs(scip, nlrow, lhs) ccall((:SCIPchgNlRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, lhs) end -function SCIPchgNlRowRhs(scip, nlrow, rhs::Cdouble) +function SCIPchgNlRowRhs(scip, nlrow, rhs) ccall((:SCIPchgNlRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, rhs) end -function SCIPchgNlRowConstant(scip, nlrow, constant::Cdouble) +function SCIPchgNlRowConstant(scip, nlrow, constant) ccall((:SCIPchgNlRowConstant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, constant) end -function SCIPaddLinearCoefToNlRow(scip, nlrow, var, val::Cdouble) +function SCIPaddLinearCoefToNlRow(scip, nlrow, var, val) ccall((:SCIPaddLinearCoefToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, val) end -function SCIPaddLinearCoefsToNlRow(scip, nlrow, nvars::Cint, vars, vals) +function SCIPaddLinearCoefsToNlRow(scip, nlrow, nvars, vars, vals) ccall((:SCIPaddLinearCoefsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nlrow, nvars, vars, vals) end -function SCIPchgNlRowLinearCoef(scip, nlrow, var, coef::Cdouble) +function SCIPchgNlRowLinearCoef(scip, nlrow, var, coef) ccall((:SCIPchgNlRowLinearCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, coef) end @@ -222,19 +222,19 @@ function SCIPaddQuadVarToNlRow(scip, nlrow, var) ccall((:SCIPaddQuadVarToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}), scip, nlrow, var) end -function SCIPaddQuadVarsToNlRow(scip, nlrow, nvars::Cint, vars) +function SCIPaddQuadVarsToNlRow(scip, nlrow, nvars, vars) ccall((:SCIPaddQuadVarsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, nlrow, nvars, vars) end -function SCIPaddQuadElementToNlRow(scip, nlrow, quadelem::SCIP_QUADELEM) +function SCIPaddQuadElementToNlRow(scip, nlrow, quadelem) ccall((:SCIPaddQuadElementToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_QUADELEM), scip, nlrow, quadelem) end -function SCIPaddQuadElementsToNlRow(scip, nlrow, nquadelems::Cint, quadelems) +function SCIPaddQuadElementsToNlRow(scip, nlrow, nquadelems, quadelems) ccall((:SCIPaddQuadElementsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{SCIP_QUADELEM}), scip, nlrow, nquadelems, quadelems) end -function SCIPchgNlRowQuadElement(scip, nlrow, quadelement::SCIP_QUADELEM) +function SCIPchgNlRowQuadElement(scip, nlrow, quadelement) ccall((:SCIPchgNlRowQuadElement, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_QUADELEM), scip, nlrow, quadelement) end @@ -242,7 +242,7 @@ function SCIPsetNlRowExprtree(scip, nlrow, exprtree) ccall((:SCIPsetNlRowExprtree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_EXPRTREE}), scip, nlrow, exprtree) end -function SCIPsetNlRowExprtreeParam(scip, nlrow, paramidx::Cint, paramval::Cdouble) +function SCIPsetNlRowExprtreeParam(scip, nlrow, paramidx, paramval) ccall((:SCIPsetNlRowExprtreeParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Cdouble), scip, nlrow, paramidx, paramval) end diff --git a/src/wrapper/scip_nodesel.jl b/src/wrapper/scip_nodesel.jl index 11ed2417..02e24942 100644 --- a/src/wrapper/scip_nodesel.jl +++ b/src/wrapper/scip_nodesel.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_nodesel.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeNodesel(scip, name, desc, stdpriority::Cint, memsavepriority::Cint, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) +function SCIPincludeNodesel(scip, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) ccall((:SCIPincludeNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) end -function SCIPincludeNodeselBasic(scip, nodesel, name, desc, stdpriority::Cint, memsavepriority::Cint, nodeselselect, nodeselcomp, nodeseldata) +function SCIPincludeNodeselBasic(scip, nodesel, name, desc, stdpriority, memsavepriority, nodeselselect, nodeselcomp, nodeseldata) ccall((:SCIPincludeNodeselBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NODESEL}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, nodesel, name, desc, stdpriority, memsavepriority, nodeselselect, nodeselcomp, nodeseldata) end @@ -46,11 +46,11 @@ function SCIPgetNNodesels(scip) ccall((:SCIPgetNNodesels, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetNodeselStdPriority(scip, nodesel, priority::Cint) +function SCIPsetNodeselStdPriority(scip, nodesel, priority) ccall((:SCIPsetNodeselStdPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) end -function SCIPsetNodeselMemsavePriority(scip, nodesel, priority::Cint) +function SCIPsetNodeselMemsavePriority(scip, nodesel, priority) ccall((:SCIPsetNodeselMemsavePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) end diff --git a/src/wrapper/scip_nonlinear.jl b/src/wrapper/scip_nonlinear.jl index 97d5e0df..fbcd8747 100644 --- a/src/wrapper/scip_nonlinear.jl +++ b/src/wrapper/scip_nonlinear.jl @@ -1,39 +1,39 @@ # Julia wrapper for header: /usr/include/scip/scip_nonlinear.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPaddSquareLinearization(scip, sqrcoef::Cdouble, refpoint::Cdouble, isint::UInt32, lincoef, linconstant, success) +function SCIPaddSquareLinearization(scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) ccall((:SCIPaddSquareLinearization, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, UInt32, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) end -function SCIPaddSquareSecant(scip, sqrcoef::Cdouble, lb::Cdouble, ub::Cdouble, refpoint::Cdouble, lincoef, linconstant, success) +function SCIPaddSquareSecant(scip, sqrcoef, lb, ub, refpoint, lincoef, linconstant, success) ccall((:SCIPaddSquareSecant, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, sqrcoef, lb, ub, refpoint, lincoef, linconstant, success) end -function SCIPaddBilinLinearization(scip, bilincoef::Cdouble, refpointx::Cdouble, refpointy::Cdouble, lincoefx, lincoefy, linconstant, success) +function SCIPaddBilinLinearization(scip, bilincoef, refpointx, refpointy, lincoefx, lincoefy, linconstant, success) ccall((:SCIPaddBilinLinearization, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, refpointx, refpointy, lincoefx, lincoefy, linconstant, success) end -function SCIPaddBilinMcCormick(scip, bilincoef::Cdouble, lbx::Cdouble, ubx::Cdouble, refpointx::Cdouble, lby::Cdouble, uby::Cdouble, refpointy::Cdouble, overestimate::UInt32, lincoefx, lincoefy, linconstant, success) +function SCIPaddBilinMcCormick(scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, lincoefx, lincoefy, linconstant, success) ccall((:SCIPaddBilinMcCormick, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, lincoefx, lincoefy, linconstant, success) end -function SCIPcomputeBilinEnvelope1(scip, bilincoef::Cdouble, lbx::Cdouble, ubx::Cdouble, refpointx::Cdouble, lby::Cdouble, uby::Cdouble, refpointy::Cdouble, overestimate::UInt32, xcoef::Cdouble, ycoef::Cdouble, constant::Cdouble, lincoefx, lincoefy, linconstant, success) +function SCIPcomputeBilinEnvelope1(scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, xcoef, ycoef, constant, lincoefx, lincoefy, linconstant, success) ccall((:SCIPcomputeBilinEnvelope1, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, xcoef, ycoef, constant, lincoefx, lincoefy, linconstant, success) end -function SCIPcomputeBilinEnvelope2(scip, bilincoef::Cdouble, lbx::Cdouble, ubx::Cdouble, refpointx::Cdouble, lby::Cdouble, uby::Cdouble, refpointy::Cdouble, overestimate::UInt32, alpha1::Cdouble, beta1::Cdouble, gamma1::Cdouble, alpha2::Cdouble, beta2::Cdouble, gamma2::Cdouble, lincoefx, lincoefy, linconstant, success) +function SCIPcomputeBilinEnvelope2(scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, alpha1, beta1, gamma1, alpha2, beta2, gamma2, lincoefx, lincoefy, linconstant, success) ccall((:SCIPcomputeBilinEnvelope2, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, alpha1, beta1, gamma1, alpha2, beta2, gamma2, lincoefx, lincoefy, linconstant, success) end -function SCIPcreateNlpiProb(scip, nlpi, nlrows, nnlrows::Cint, nlpiprob, var2idx, nlscore, cutoffbound::Cdouble, setobj::UInt32, onlyconvex::UInt32) +function SCIPcreateNlpiProb(scip, nlpi, nlrows, nnlrows, nlpiprob, var2idx, nlscore, cutoffbound, setobj, onlyconvex) ccall((:SCIPcreateNlpiProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLROW}}, Cint, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Cdouble}, Cdouble, UInt32, UInt32), scip, nlpi, nlrows, nnlrows, nlpiprob, var2idx, nlscore, cutoffbound, setobj, onlyconvex) end -function SCIPupdateNlpiProb(scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars::Cint, cutoffbound::Cdouble) +function SCIPupdateNlpiProb(scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) ccall((:SCIPupdateNlpiProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cdouble), scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) end -function SCIPaddNlpiProbRows(scip, nlpi, nlpiprob, var2idx, rows, nrows::Cint) +function SCIPaddNlpiProbRows(scip, nlpi, nlpiprob, var2idx, rows, nrows) ccall((:SCIPaddNlpiProbRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_ROW}}, Cint), scip, nlpi, nlpiprob, var2idx, rows, nrows) end diff --git a/src/wrapper/scip_numerics.jl b/src/wrapper/scip_numerics.jl index a3612728..4e4db339 100644 --- a/src/wrapper/scip_numerics.jl +++ b/src/wrapper/scip_numerics.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_numerics.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPepsilon(scip) @@ -34,23 +34,23 @@ function SCIPrelaxfeastol(scip) ccall((:SCIPrelaxfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPchgFeastol(scip, feastol::Cdouble) +function SCIPchgFeastol(scip, feastol) ccall((:SCIPchgFeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, feastol) end -function SCIPchgLpfeastol(scip, lpfeastol::Cdouble, printnewvalue::UInt32) +function SCIPchgLpfeastol(scip, lpfeastol, printnewvalue) ccall((:SCIPchgLpfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, UInt32), scip, lpfeastol, printnewvalue) end -function SCIPchgDualfeastol(scip, dualfeastol::Cdouble) +function SCIPchgDualfeastol(scip, dualfeastol) ccall((:SCIPchgDualfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, dualfeastol) end -function SCIPchgBarrierconvtol(scip, barrierconvtol::Cdouble) +function SCIPchgBarrierconvtol(scip, barrierconvtol) ccall((:SCIPchgBarrierconvtol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, barrierconvtol) end -function SCIPchgRelaxfeastol(scip, relaxfeastol::Cdouble) +function SCIPchgRelaxfeastol(scip, relaxfeastol) ccall((:SCIPchgRelaxfeastol, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, relaxfeastol) end @@ -66,279 +66,279 @@ function SCIPgetHugeValue(scip) ccall((:SCIPgetHugeValue, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPisEQ(scip, val1::Cdouble, val2::Cdouble) +function SCIPisEQ(scip, val1, val2) ccall((:SCIPisEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisLT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisLT(scip, val1, val2) ccall((:SCIPisLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisLE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisLE(scip, val1, val2) ccall((:SCIPisLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisGT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisGT(scip, val1, val2) ccall((:SCIPisGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisGE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisGE(scip, val1, val2) ccall((:SCIPisGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisInfinity(scip, val::Cdouble) +function SCIPisInfinity(scip, val) ccall((:SCIPisInfinity, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisHugeValue(scip, val::Cdouble) +function SCIPisHugeValue(scip, val) ccall((:SCIPisHugeValue, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisZero(scip, val::Cdouble) +function SCIPisZero(scip, val) ccall((:SCIPisZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisPositive(scip, val::Cdouble) +function SCIPisPositive(scip, val) ccall((:SCIPisPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisNegative(scip, val::Cdouble) +function SCIPisNegative(scip, val) ccall((:SCIPisNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisIntegral(scip, val::Cdouble) +function SCIPisIntegral(scip, val) ccall((:SCIPisIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisScalingIntegral(scip, val::Cdouble, scalar::Cdouble) +function SCIPisScalingIntegral(scip, val, scalar) ccall((:SCIPisScalingIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val, scalar) end -function SCIPisFracIntegral(scip, val::Cdouble) +function SCIPisFracIntegral(scip, val) ccall((:SCIPisFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPfloor(scip, val::Cdouble) +function SCIPfloor(scip, val) ccall((:SCIPfloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPceil(scip, val::Cdouble) +function SCIPceil(scip, val) ccall((:SCIPceil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPround(scip, val::Cdouble) +function SCIPround(scip, val) ccall((:SCIPround, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPfrac(scip, val::Cdouble) +function SCIPfrac(scip, val) ccall((:SCIPfrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisSumEQ(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumEQ(scip, val1, val2) ccall((:SCIPisSumEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumLT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumLT(scip, val1, val2) ccall((:SCIPisSumLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumLE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumLE(scip, val1, val2) ccall((:SCIPisSumLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumGT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumGT(scip, val1, val2) ccall((:SCIPisSumGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumGE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumGE(scip, val1, val2) ccall((:SCIPisSumGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumZero(scip, val::Cdouble) +function SCIPisSumZero(scip, val) ccall((:SCIPisSumZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisSumPositive(scip, val::Cdouble) +function SCIPisSumPositive(scip, val) ccall((:SCIPisSumPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisSumNegative(scip, val::Cdouble) +function SCIPisSumNegative(scip, val) ccall((:SCIPisSumNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisFeasEQ(scip, val1::Cdouble, val2::Cdouble) +function SCIPisFeasEQ(scip, val1, val2) ccall((:SCIPisFeasEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisFeasLT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisFeasLT(scip, val1, val2) ccall((:SCIPisFeasLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisFeasLE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisFeasLE(scip, val1, val2) ccall((:SCIPisFeasLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisFeasGT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisFeasGT(scip, val1, val2) ccall((:SCIPisFeasGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisFeasGE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisFeasGE(scip, val1, val2) ccall((:SCIPisFeasGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisFeasZero(scip, val::Cdouble) +function SCIPisFeasZero(scip, val) ccall((:SCIPisFeasZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisFeasPositive(scip, val::Cdouble) +function SCIPisFeasPositive(scip, val) ccall((:SCIPisFeasPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisFeasNegative(scip, val::Cdouble) +function SCIPisFeasNegative(scip, val) ccall((:SCIPisFeasNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisFeasIntegral(scip, val::Cdouble) +function SCIPisFeasIntegral(scip, val) ccall((:SCIPisFeasIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisFeasFracIntegral(scip, val::Cdouble) +function SCIPisFeasFracIntegral(scip, val) ccall((:SCIPisFeasFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPfeasFloor(scip, val::Cdouble) +function SCIPfeasFloor(scip, val) ccall((:SCIPfeasFloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPfeasCeil(scip, val::Cdouble) +function SCIPfeasCeil(scip, val) ccall((:SCIPfeasCeil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPfeasRound(scip, val::Cdouble) +function SCIPfeasRound(scip, val) ccall((:SCIPfeasRound, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPfeasFrac(scip, val::Cdouble) +function SCIPfeasFrac(scip, val) ccall((:SCIPfeasFrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisDualfeasEQ(scip, val1::Cdouble, val2::Cdouble) +function SCIPisDualfeasEQ(scip, val1, val2) ccall((:SCIPisDualfeasEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisDualfeasLT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisDualfeasLT(scip, val1, val2) ccall((:SCIPisDualfeasLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisDualfeasLE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisDualfeasLE(scip, val1, val2) ccall((:SCIPisDualfeasLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisDualfeasGT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisDualfeasGT(scip, val1, val2) ccall((:SCIPisDualfeasGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisDualfeasGE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisDualfeasGE(scip, val1, val2) ccall((:SCIPisDualfeasGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisDualfeasZero(scip, val::Cdouble) +function SCIPisDualfeasZero(scip, val) ccall((:SCIPisDualfeasZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisDualfeasPositive(scip, val::Cdouble) +function SCIPisDualfeasPositive(scip, val) ccall((:SCIPisDualfeasPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisDualfeasNegative(scip, val::Cdouble) +function SCIPisDualfeasNegative(scip, val) ccall((:SCIPisDualfeasNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisDualfeasIntegral(scip, val::Cdouble) +function SCIPisDualfeasIntegral(scip, val) ccall((:SCIPisDualfeasIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisDualfeasFracIntegral(scip, val::Cdouble) +function SCIPisDualfeasFracIntegral(scip, val) ccall((:SCIPisDualfeasFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPdualfeasFloor(scip, val::Cdouble) +function SCIPdualfeasFloor(scip, val) ccall((:SCIPdualfeasFloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPdualfeasCeil(scip, val::Cdouble) +function SCIPdualfeasCeil(scip, val) ccall((:SCIPdualfeasCeil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPdualfeasRound(scip, val::Cdouble) +function SCIPdualfeasRound(scip, val) ccall((:SCIPdualfeasRound, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPdualfeasFrac(scip, val::Cdouble) +function SCIPdualfeasFrac(scip, val) ccall((:SCIPdualfeasFrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end -function SCIPisLbBetter(scip, newlb::Cdouble, oldlb::Cdouble, oldub::Cdouble) +function SCIPisLbBetter(scip, newlb, oldlb, oldub) ccall((:SCIPisLbBetter, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newlb, oldlb, oldub) end -function SCIPisUbBetter(scip, newub::Cdouble, oldlb::Cdouble, oldub::Cdouble) +function SCIPisUbBetter(scip, newub, oldlb, oldub) ccall((:SCIPisUbBetter, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newub, oldlb, oldub) end -function SCIPisRelEQ(scip, val1::Cdouble, val2::Cdouble) +function SCIPisRelEQ(scip, val1, val2) ccall((:SCIPisRelEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisRelLT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisRelLT(scip, val1, val2) ccall((:SCIPisRelLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisRelLE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisRelLE(scip, val1, val2) ccall((:SCIPisRelLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisRelGT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisRelGT(scip, val1, val2) ccall((:SCIPisRelGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisRelGE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisRelGE(scip, val1, val2) ccall((:SCIPisRelGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumRelEQ(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumRelEQ(scip, val1, val2) ccall((:SCIPisSumRelEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumRelLT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumRelLT(scip, val1, val2) ccall((:SCIPisSumRelLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumRelLE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumRelLE(scip, val1, val2) ccall((:SCIPisSumRelLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumRelGT(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumRelGT(scip, val1, val2) ccall((:SCIPisSumRelGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPisSumRelGE(scip, val1::Cdouble, val2::Cdouble) +function SCIPisSumRelGE(scip, val1, val2) ccall((:SCIPisSumRelGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end -function SCIPconvertRealToInt(scip, real::Cdouble) +function SCIPconvertRealToInt(scip, real) ccall((:SCIPconvertRealToInt, libscip), Cint, (Ptr{SCIP}, Cdouble), scip, real) end -function SCIPconvertRealToLongint(scip, real::Cdouble) +function SCIPconvertRealToLongint(scip, real) ccall((:SCIPconvertRealToLongint, libscip), Clonglong, (Ptr{SCIP}, Cdouble), scip, real) end -function SCIPisUpdateUnreliable(scip, newvalue::Cdouble, oldvalue::Cdouble) +function SCIPisUpdateUnreliable(scip, newvalue, oldvalue) ccall((:SCIPisUpdateUnreliable, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, newvalue, oldvalue) end -function SCIPprintReal(scip, file, val::Cdouble, width::Cint, precision::Cint) +function SCIPprintReal(scip, file, val, width, precision) ccall((:SCIPprintReal, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}, Cdouble, Cint, Cint), scip, file, val, width, precision) end diff --git a/src/wrapper/scip_param.jl b/src/wrapper/scip_param.jl index 83464d27..2093e1da 100644 --- a/src/wrapper/scip_param.jl +++ b/src/wrapper/scip_param.jl @@ -1,28 +1,28 @@ # Julia wrapper for header: /usr/include/scip/scip_param.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPaddBoolParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::UInt32, paramchgd, paramdata) +function SCIPaddBoolParam(scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) ccall((:SCIPaddBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{UInt32}, UInt32, UInt32, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) end -function SCIPaddIntParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::Cint, minvalue::Cint, maxvalue::Cint, paramchgd, paramdata) +function SCIPaddIntParam(scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) ccall((:SCIPaddIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cint}, UInt32, Cint, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end -function SCIPaddLongintParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::Clonglong, minvalue::Clonglong, maxvalue::Clonglong, paramchgd, paramdata) +function SCIPaddLongintParam(scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) ccall((:SCIPaddLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Clonglong}, UInt32, Clonglong, Clonglong, Clonglong, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end -function SCIPaddRealParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::Cdouble, minvalue::Cdouble, maxvalue::Cdouble, paramchgd, paramdata) +function SCIPaddRealParam(scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) ccall((:SCIPaddRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cdouble}, UInt32, Cdouble, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end -function SCIPaddCharParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue::UInt8, allowedvalues, paramchgd, paramdata) +function SCIPaddCharParam(scip, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) ccall((:SCIPaddCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cstring, UInt32, UInt8, Cstring, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) end -function SCIPaddStringParam(scip, name, desc, valueptr, isadvanced::UInt32, defaultvalue, paramchgd, paramdata) +function SCIPaddStringParam(scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) ccall((:SCIPaddStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cstring}, UInt32, Cstring, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) end @@ -70,63 +70,63 @@ function SCIPsetParam(scip, name, value) ccall((:SCIPsetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cvoid}), scip, name, value) end -function SCIPchgBoolParam(scip, param, value::UInt32) +function SCIPchgBoolParam(scip, param, value) ccall((:SCIPchgBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt32), scip, param, value) end -function SCIPsetBoolParam(scip, name, value::UInt32) +function SCIPsetBoolParam(scip, name, value) ccall((:SCIPsetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32), scip, name, value) end -function SCIPisBoolParamValid(scip, param, value::UInt32) +function SCIPisBoolParamValid(scip, param, value) ccall((:SCIPisBoolParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt32), scip, param, value) end -function SCIPchgIntParam(scip, param, value::Cint) +function SCIPchgIntParam(scip, param, value) ccall((:SCIPchgIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) end -function SCIPsetIntParam(scip, name, value::Cint) +function SCIPsetIntParam(scip, name, value) ccall((:SCIPsetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cint), scip, name, value) end -function SCIPisIntParamValid(scip, param, value::Cint) +function SCIPisIntParamValid(scip, param, value) ccall((:SCIPisIntParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) end -function SCIPchgLongintParam(scip, param, value::Clonglong) +function SCIPchgLongintParam(scip, param, value) ccall((:SCIPchgLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) end -function SCIPsetLongintParam(scip, name, value::Clonglong) +function SCIPsetLongintParam(scip, name, value) ccall((:SCIPsetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Clonglong), scip, name, value) end -function SCIPisLongintParamValid(scip, param, value::Clonglong) +function SCIPisLongintParamValid(scip, param, value) ccall((:SCIPisLongintParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) end -function SCIPchgRealParam(scip, param, value::Cdouble) +function SCIPchgRealParam(scip, param, value) ccall((:SCIPchgRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) end -function SCIPsetRealParam(scip, name, value::Cdouble) +function SCIPsetRealParam(scip, name, value) ccall((:SCIPsetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cdouble), scip, name, value) end -function SCIPisRealParamValid(scip, param, value::Cdouble) +function SCIPisRealParamValid(scip, param, value) ccall((:SCIPisRealParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) end -function SCIPchgCharParam(scip, param, value::UInt8) +function SCIPchgCharParam(scip, param, value) ccall((:SCIPchgCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt8), scip, param, value) end -function SCIPsetCharParam(scip, name, value::UInt8) +function SCIPsetCharParam(scip, name, value) ccall((:SCIPsetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt8), scip, name, value) end -function SCIPisCharParamValid(scip, param, value::UInt8) +function SCIPisCharParamValid(scip, param, value) ccall((:SCIPisCharParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt8), scip, param, value) end @@ -146,11 +146,11 @@ function SCIPreadParams(scip, filename) ccall((:SCIPreadParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) end -function SCIPwriteParam(scip, param, filename, comments::UInt32, onlychanged::UInt32) +function SCIPwriteParam(scip, param, filename, comments, onlychanged) ccall((:SCIPwriteParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cstring, UInt32, UInt32), scip, param, filename, comments, onlychanged) end -function SCIPwriteParams(scip, filename, comments::UInt32, onlychanged::UInt32) +function SCIPwriteParams(scip, filename, comments, onlychanged) ccall((:SCIPwriteParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32, UInt32), scip, filename, comments, onlychanged) end @@ -162,23 +162,23 @@ function SCIPresetParams(scip) ccall((:SCIPresetParams, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPsetEmphasis(scip, paramemphasis::SCIP_PARAMEMPHASIS, quiet::UInt32) +function SCIPsetEmphasis(scip, paramemphasis, quiet) ccall((:SCIPsetEmphasis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMEMPHASIS, UInt32), scip, paramemphasis, quiet) end -function SCIPsetSubscipsOff(scip, quiet::UInt32) +function SCIPsetSubscipsOff(scip, quiet) ccall((:SCIPsetSubscipsOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, quiet) end -function SCIPsetHeuristics(scip, paramsetting::SCIP_PARAMSETTING, quiet::UInt32) +function SCIPsetHeuristics(scip, paramsetting, quiet) ccall((:SCIPsetHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) end -function SCIPsetPresolving(scip, paramsetting::SCIP_PARAMSETTING, quiet::UInt32) +function SCIPsetPresolving(scip, paramsetting, quiet) ccall((:SCIPsetPresolving, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) end -function SCIPsetSeparating(scip, paramsetting::SCIP_PARAMSETTING, quiet::UInt32) +function SCIPsetSeparating(scip, paramsetting, quiet) ccall((:SCIPsetSeparating, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) end diff --git a/src/wrapper/scip_presol.jl b/src/wrapper/scip_presol.jl index 625bd581..bda0b512 100644 --- a/src/wrapper/scip_presol.jl +++ b/src/wrapper/scip_presol.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_presol.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludePresol(scip, name, desc, priority::Cint, maxrounds::Cint, timing::SCIP_PRESOLTIMING, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) +function SCIPincludePresol(scip, name, desc, priority, maxrounds, timing, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) ccall((:SCIPincludePresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, name, desc, priority, maxrounds, timing, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) end -function SCIPincludePresolBasic(scip, presolptr, name, desc, priority::Cint, maxrounds::Cint, timing::SCIP_PRESOLTIMING, presolexec, presoldata) +function SCIPincludePresolBasic(scip, presolptr, name, desc, priority, maxrounds, timing, presolexec, presoldata) ccall((:SCIPincludePresolBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PRESOL}}, Cstring, Cstring, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, presolptr, name, desc, priority, maxrounds, timing, presolexec, presoldata) end @@ -46,6 +46,6 @@ function SCIPgetNPresols(scip) ccall((:SCIPgetNPresols, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetPresolPriority(scip, presol, priority::Cint) +function SCIPsetPresolPriority(scip, presol, priority) ccall((:SCIPsetPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Cint), scip, presol, priority) end diff --git a/src/wrapper/scip_pricer.jl b/src/wrapper/scip_pricer.jl index 45303698..5fa0ef77 100644 --- a/src/wrapper/scip_pricer.jl +++ b/src/wrapper/scip_pricer.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_pricer.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludePricer(scip, name, desc, priority::Cint, delay::UInt32, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) +function SCIPincludePricer(scip, name, desc, priority, delay, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) ccall((:SCIPincludePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, name, desc, priority, delay, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) end -function SCIPincludePricerBasic(scip, pricerptr, name, desc, priority::Cint, delay::UInt32, pricerredcost, pricerfarkas, pricerdata) +function SCIPincludePricerBasic(scip, pricerptr, name, desc, priority, delay, pricerredcost, pricerfarkas, pricerdata) ccall((:SCIPincludePricerBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PRICER}}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, pricerptr, name, desc, priority, delay, pricerredcost, pricerfarkas, pricerdata) end @@ -50,7 +50,7 @@ function SCIPgetNActivePricers(scip) ccall((:SCIPgetNActivePricers, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetPricerPriority(scip, pricer, priority::Cint) +function SCIPsetPricerPriority(scip, pricer, priority) ccall((:SCIPsetPricerPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Cint), scip, pricer, priority) end diff --git a/src/wrapper/scip_prob.jl b/src/wrapper/scip_prob.jl index 3612d925..c07736d8 100644 --- a/src/wrapper/scip_prob.jl +++ b/src/wrapper/scip_prob.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_prob.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPcreateProb(scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) @@ -38,11 +38,11 @@ function SCIPreadProb(scip, filename, extension) ccall((:SCIPreadProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, filename, extension) end -function SCIPwriteOrigProblem(scip, filename, extension, genericnames::UInt32) +function SCIPwriteOrigProblem(scip, filename, extension, genericnames) ccall((:SCIPwriteOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32), scip, filename, extension, genericnames) end -function SCIPwriteTransProblem(scip, filename, extension, genericnames::UInt32) +function SCIPwriteTransProblem(scip, filename, extension, genericnames) ccall((:SCIPwriteTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32), scip, filename, extension, genericnames) end @@ -50,7 +50,7 @@ function SCIPfreeProb(scip) ccall((:SCIPfreeProb, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPpermuteProb(scip, randseed::UInt32, permuteconss::UInt32, permutebinvars::UInt32, permuteintvars::UInt32, permuteimplvars::UInt32, permutecontvars::UInt32) +function SCIPpermuteProb(scip, randseed, permuteconss, permutebinvars, permuteintvars, permuteimplvars, permutecontvars) ccall((:SCIPpermuteProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, randseed, permuteconss, permutebinvars, permuteintvars, permuteimplvars, permutecontvars) end @@ -70,7 +70,7 @@ function SCIPsetProbName(scip, name) ccall((:SCIPsetProbName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) end -function SCIPchgReoptObjective(scip, objsense::SCIP_OBJSENSE, vars, coefs, nvars::Cint) +function SCIPchgReoptObjective(scip, objsense, vars, coefs, nvars) ccall((:SCIPchgReoptObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), scip, objsense, vars, coefs, nvars) end @@ -78,15 +78,15 @@ function SCIPgetObjsense(scip) ccall((:SCIPgetObjsense, libscip), SCIP_OBJSENSE, (Ptr{SCIP},), scip) end -function SCIPsetObjsense(scip, objsense::SCIP_OBJSENSE) +function SCIPsetObjsense(scip, objsense) ccall((:SCIPsetObjsense, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE), scip, objsense) end -function SCIPaddObjoffset(scip, addval::Cdouble) +function SCIPaddObjoffset(scip, addval) ccall((:SCIPaddObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) end -function SCIPaddOrigObjoffset(scip, addval::Cdouble) +function SCIPaddOrigObjoffset(scip, addval) ccall((:SCIPaddOrigObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) end @@ -106,7 +106,7 @@ function SCIPgetTransObjscale(scip) ccall((:SCIPgetTransObjscale, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPsetObjlimit(scip, objlimit::Cdouble) +function SCIPsetObjlimit(scip, objlimit) ccall((:SCIPsetObjlimit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, objlimit) end @@ -130,7 +130,7 @@ function SCIPaddVar(scip, var) ccall((:SCIPaddVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPaddPricedVar(scip, var, score::Cdouble) +function SCIPaddPricedVar(scip, var, score) ccall((:SCIPaddPricedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, score) end @@ -262,7 +262,7 @@ function SCIPgetNCheckConss(scip) ccall((:SCIPgetNCheckConss, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPaddConflict(scip, node, cons, validnode, conftype::SCIP_CONFTYPE, iscutoffinvolved::UInt32) +function SCIPaddConflict(scip, node, cons, validnode, conftype, iscutoffinvolved) ccall((:SCIPaddConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}, SCIP_CONFTYPE, UInt32), scip, node, cons, validnode, conftype, iscutoffinvolved) end @@ -310,22 +310,22 @@ function SCIPgetNodeLowerbound(scip, node) ccall((:SCIPgetNodeLowerbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) end -function SCIPupdateLocalDualbound(scip, newbound::Cdouble) +function SCIPupdateLocalDualbound(scip, newbound) ccall((:SCIPupdateLocalDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) end -function SCIPupdateLocalLowerbound(scip, newbound::Cdouble) +function SCIPupdateLocalLowerbound(scip, newbound) ccall((:SCIPupdateLocalLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) end -function SCIPupdateNodeDualbound(scip, node, newbound::Cdouble) +function SCIPupdateNodeDualbound(scip, node, newbound) ccall((:SCIPupdateNodeDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) end -function SCIPupdateNodeLowerbound(scip, node, newbound::Cdouble) +function SCIPupdateNodeLowerbound(scip, node, newbound) ccall((:SCIPupdateNodeLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) end -function SCIPchgChildPrio(scip, child, priority::Cdouble) +function SCIPchgChildPrio(scip, child, priority) ccall((:SCIPchgChildPrio, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, child, priority) end diff --git a/src/wrapper/scip_probing.jl b/src/wrapper/scip_probing.jl index 6b7c4647..eca9b651 100644 --- a/src/wrapper/scip_probing.jl +++ b/src/wrapper/scip_probing.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_probing.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPinProbing(scip) @@ -18,7 +18,7 @@ function SCIPgetProbingDepth(scip) ccall((:SCIPgetProbingDepth, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPbacktrackProbing(scip, probingdepth::Cint) +function SCIPbacktrackProbing(scip, probingdepth) ccall((:SCIPbacktrackProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint), scip, probingdepth) end @@ -26,11 +26,11 @@ function SCIPendProbing(scip) ccall((:SCIPendProbing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPchgVarLbProbing(scip, var, newbound::Cdouble) +function SCIPchgVarLbProbing(scip, var, newbound) ccall((:SCIPchgVarLbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end -function SCIPchgVarUbProbing(scip, var, newbound::Cdouble) +function SCIPchgVarUbProbing(scip, var, newbound) ccall((:SCIPchgVarUbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end @@ -38,11 +38,11 @@ function SCIPgetVarObjProbing(scip, var) ccall((:SCIPgetVarObjProbing, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPfixVarProbing(scip, var, fixedval::Cdouble) +function SCIPfixVarProbing(scip, var, fixedval) ccall((:SCIPfixVarProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, fixedval) end -function SCIPchgVarObjProbing(scip, var, newobj::Cdouble) +function SCIPchgVarObjProbing(scip, var, newobj) ccall((:SCIPchgVarObjProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end @@ -50,7 +50,7 @@ function SCIPisObjChangedProbing(scip) ccall((:SCIPisObjChangedProbing, libscip), UInt32, (Ptr{SCIP},), scip) end -function SCIPpropagateProbing(scip, maxproprounds::Cint, cutoff, ndomredsfound) +function SCIPpropagateProbing(scip, maxproprounds, cutoff, ndomredsfound) ccall((:SCIPpropagateProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{Clonglong}), scip, maxproprounds, cutoff, ndomredsfound) end @@ -58,15 +58,15 @@ function SCIPpropagateProbingImplications(scip, cutoff) ccall((:SCIPpropagateProbingImplications, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) end -function SCIPsolveProbingLP(scip, itlim::Cint, lperror, cutoff) +function SCIPsolveProbingLP(scip, itlim, lperror, cutoff) ccall((:SCIPsolveProbingLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, itlim, lperror, cutoff) end -function SCIPsolveProbingLPWithPricing(scip, pretendroot::UInt32, displayinfo::UInt32, maxpricerounds::Cint, lperror, cutoff) +function SCIPsolveProbingLPWithPricing(scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) ccall((:SCIPsolveProbingLPWithPricing, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) end -function SCIPsetProbingLPState(scip, lpistate, lpinorms, primalfeas::UInt32, dualfeas::UInt32) +function SCIPsetProbingLPState(scip, lpistate, lpinorms, primalfeas, dualfeas) ccall((:SCIPsetProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LPISTATE}}, Ptr{Ptr{SCIP_LPINORMS}}, UInt32, UInt32), scip, lpistate, lpinorms, primalfeas, dualfeas) end @@ -82,15 +82,15 @@ function SCIPsolveProbingRelax(scip, cutoff) ccall((:SCIPsolveProbingRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) end -function SCIPgetDivesetScore(scip, diveset, divetype::SCIP_DIVETYPE, divecand, divecandsol::Cdouble, divecandfrac::Cdouble, candscore, roundup) +function SCIPgetDivesetScore(scip, diveset, divetype, divecand, divecandsol, divecandfrac, candscore, roundup) ccall((:SCIPgetDivesetScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, SCIP_DIVETYPE, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{UInt32}), scip, diveset, divetype, divecand, divecandsol, divecandfrac, candscore, roundup) end -function SCIPupdateDivesetLPStats(scip, diveset, niterstoadd::Clonglong) +function SCIPupdateDivesetLPStats(scip, diveset, niterstoadd) ccall((:SCIPupdateDivesetLPStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Clonglong), scip, diveset, niterstoadd) end -function SCIPupdateDivesetStats(scip, diveset, nprobingnodes::Cint, nbacktracks::Cint, nsolsfound::Clonglong, nbestsolsfound::Clonglong, nconflictsfound::Clonglong, leavewassol::UInt32) +function SCIPupdateDivesetStats(scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol) ccall((:SCIPupdateDivesetStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Cint, Cint, Clonglong, Clonglong, Clonglong, UInt32), scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol) end @@ -98,11 +98,11 @@ function SCIPgetDiveBoundChanges(scip, diveset, sol, success, infeasible) ccall((:SCIPgetDiveBoundChanges, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{UInt32}, Ptr{UInt32}), scip, diveset, sol, success, infeasible) end -function SCIPaddDiveBoundChange(scip, var, dir::SCIP_BRANCHDIR, value::Cdouble, preferred::UInt32) +function SCIPaddDiveBoundChange(scip, var, dir, value, preferred) ccall((:SCIPaddDiveBoundChange, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble, UInt32), scip, var, dir, value, preferred) end -function SCIPgetDiveBoundChangeData(scip, variables, directions, values, ndivebdchgs, preferred::UInt32) +function SCIPgetDiveBoundChangeData(scip, variables, directions, values, ndivebdchgs, preferred) ccall((:SCIPgetDiveBoundChangeData, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{SCIP_BRANCHDIR}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, UInt32), scip, variables, directions, values, ndivebdchgs, preferred) end diff --git a/src/wrapper/scip_prop.jl b/src/wrapper/scip_prop.jl index ad81f077..7e031a6f 100644 --- a/src/wrapper/scip_prop.jl +++ b/src/wrapper/scip_prop.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_prop.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeProp(scip, name, desc, priority::Cint, freq::Cint, delay::UInt32, timingmask::SCIP_PROPTIMING, presolpriority::Cint, presolmaxrounds::Cint, presoltiming::SCIP_PRESOLTIMING, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) +function SCIPincludeProp(scip, name, desc, priority, freq, delay, timingmask, presolpriority, presolmaxrounds, presoltiming, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) ccall((:SCIPincludeProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, UInt32, SCIP_PROPTIMING, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, name, desc, priority, freq, delay, timingmask, presolpriority, presolmaxrounds, presoltiming, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) end -function SCIPincludePropBasic(scip, propptr, name, desc, priority::Cint, freq::Cint, delay::UInt32, timingmask::SCIP_PROPTIMING, propexec, propdata) +function SCIPincludePropBasic(scip, propptr, name, desc, priority, freq, delay, timingmask, propexec, propdata) ccall((:SCIPincludePropBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PROP}}, Cstring, Cstring, Cint, Cint, UInt32, SCIP_PROPTIMING, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, propptr, name, desc, priority, freq, delay, timingmask, propexec, propdata) end @@ -42,7 +42,7 @@ function SCIPsetPropExitpre(scip, prop, propexitpre) ccall((:SCIPsetPropExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitpre) end -function SCIPsetPropPresol(scip, prop, proppresol, presolpriority::Cint, presolmaxrounds::Cint, presoltiming::SCIP_PRESOLTIMING) +function SCIPsetPropPresol(scip, prop, proppresol, presolpriority, presolmaxrounds, presoltiming) ccall((:SCIPsetPropPresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}, Cint, Cint, SCIP_PRESOLTIMING), scip, prop, proppresol, presolpriority, presolmaxrounds, presoltiming) end @@ -62,10 +62,10 @@ function SCIPgetNProps(scip) ccall((:SCIPgetNProps, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetPropPriority(scip, prop, priority::Cint) +function SCIPsetPropPriority(scip, prop, priority) ccall((:SCIPsetPropPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, priority) end -function SCIPsetPropPresolPriority(scip, prop, presolpriority::Cint) +function SCIPsetPropPresolPriority(scip, prop, presolpriority) ccall((:SCIPsetPropPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, presolpriority) end diff --git a/src/wrapper/scip_randnumgen.jl b/src/wrapper/scip_randnumgen.jl index feb27293..f34ca688 100644 --- a/src/wrapper/scip_randnumgen.jl +++ b/src/wrapper/scip_randnumgen.jl @@ -1,8 +1,8 @@ # Julia wrapper for header: /usr/include/scip/scip_randnumgen.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPcreateRandom(scip, randnumgen, initialseed::UInt32, useglobalseed::UInt32) +function SCIPcreateRandom(scip, randnumgen, initialseed, useglobalseed) ccall((:SCIPcreateRandom, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}, UInt32, UInt32), scip, randnumgen, initialseed, useglobalseed) end @@ -10,10 +10,10 @@ function SCIPfreeRandom(scip, randnumgen) ccall((:SCIPfreeRandom, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}), scip, randnumgen) end -function SCIPsetRandomSeed(scip, randnumgen, seed::UInt32) +function SCIPsetRandomSeed(scip, randnumgen, seed) ccall((:SCIPsetRandomSeed, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RANDNUMGEN}, UInt32), scip, randnumgen, seed) end -function SCIPinitializeRandomSeed(scip, initialseedvalue::UInt32) +function SCIPinitializeRandomSeed(scip, initialseedvalue) ccall((:SCIPinitializeRandomSeed, libscip), UInt32, (Ptr{SCIP}, UInt32), scip, initialseedvalue) end diff --git a/src/wrapper/scip_reader.jl b/src/wrapper/scip_reader.jl index 152bff73..c330d786 100644 --- a/src/wrapper/scip_reader.jl +++ b/src/wrapper/scip_reader.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_reader.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPincludeReader(scip, name, desc, extension, readercopy, readerfree, readerread, readerwrite, readerdata) diff --git a/src/wrapper/scip_relax.jl b/src/wrapper/scip_relax.jl index 3ef1c82f..b9693e9c 100644 --- a/src/wrapper/scip_relax.jl +++ b/src/wrapper/scip_relax.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_relax.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeRelax(scip, name, desc, priority::Cint, freq::Cint, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) +function SCIPincludeRelax(scip, name, desc, priority, freq, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) ccall((:SCIPincludeRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, name, desc, priority, freq, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) end -function SCIPincludeRelaxBasic(scip, relaxptr, name, desc, priority::Cint, freq::Cint, relaxexec, relaxdata) +function SCIPincludeRelaxBasic(scip, relaxptr, name, desc, priority, freq, relaxexec, relaxdata) ccall((:SCIPincludeRelaxBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_RELAX}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, relaxptr, name, desc, priority, freq, relaxexec, relaxdata) end @@ -46,6 +46,6 @@ function SCIPgetNRelaxs(scip) ccall((:SCIPgetNRelaxs, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetRelaxPriority(scip, relax, priority::Cint) +function SCIPsetRelaxPriority(scip, relax, priority) ccall((:SCIPsetRelaxPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint), scip, relax, priority) end diff --git a/src/wrapper/scip_reopt.jl b/src/wrapper/scip_reopt.jl index f26f6665..0dffd9db 100644 --- a/src/wrapper/scip_reopt.jl +++ b/src/wrapper/scip_reopt.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_reopt.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPgetReoptChildIDs(scip, node, ids, mem::Cint, nids) +function SCIPgetReoptChildIDs(scip, node, ids, mem, nids) ccall((:SCIPgetReoptChildIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}, Cint, Ptr{Cint}), scip, node, ids, mem, nids) end -function SCIPgetReoptLeaveIDs(scip, node, ids, mem::Cint, nids) +function SCIPgetReoptLeaveIDs(scip, node, ids, mem, nids) ccall((:SCIPgetReoptLeaveIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}, Cint, Ptr{Cint}), scip, node, ids, mem, nids) end @@ -18,39 +18,39 @@ function SCIPgetNReoptLeaves(scip, node) ccall((:SCIPgetNReoptLeaves, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) end -function SCIPgetReoptnode(scip, id::UInt32) +function SCIPgetReoptnode(scip, id) ccall((:SCIPgetReoptnode, libscip), Ptr{SCIP_REOPTNODE}, (Ptr{SCIP}, UInt32), scip, id) end -function SCIPaddReoptnodeBndchg(scip, reoptnode, var, bound::Cdouble, boundtype::SCIP_BOUNDTYPE) +function SCIPaddReoptnodeBndchg(scip, reoptnode, var, bound, boundtype) ccall((:SCIPaddReoptnodeBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{SCIP_VAR}, Cdouble, SCIP_BOUNDTYPE), scip, reoptnode, var, bound, boundtype) end -function SCIPsetReoptCompression(scip, representation, nrepresentatives::Cint, success) +function SCIPsetReoptCompression(scip, representation, nrepresentatives, success) ccall((:SCIPsetReoptCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint, Ptr{UInt32}), scip, representation, nrepresentatives, success) end -function SCIPaddReoptnodeCons(scip, reoptnode, vars, vals, boundtypes, lhs::Cdouble, rhs::Cdouble, nvars::Cint, constype::REOPT_CONSTYPE, linear::UInt32) +function SCIPaddReoptnodeCons(scip, reoptnode, vars, vals, boundtypes, lhs, rhs, nvars, constype, linear) ccall((:SCIPaddReoptnodeCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cdouble, Cdouble, Cint, REOPT_CONSTYPE, UInt32), scip, reoptnode, vars, vals, boundtypes, lhs, rhs, nvars, constype, linear) end -function SCIPgetReoptnodePath(scip, reoptnode, vars, vals, boundtypes, mem::Cint, nvars, nafterdualvars) +function SCIPgetReoptnodePath(scip, reoptnode, vars, vals, boundtypes, mem, nvars, nafterdualvars) ccall((:SCIPgetReoptnodePath, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cint, Ptr{Cint}, Ptr{Cint}), scip, reoptnode, vars, vals, boundtypes, mem, nvars, nafterdualvars) end -function SCIPinitRepresentation(scip, representatives, nrepresentatives::Cint) +function SCIPinitRepresentation(scip, representatives, nrepresentatives) ccall((:SCIPinitRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) end -function SCIPresetRepresentation(scip, representatives, nrepresentatives::Cint) +function SCIPresetRepresentation(scip, representatives, nrepresentatives) ccall((:SCIPresetRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) end -function SCIPfreeRepresentation(scip, representatives, nrepresentatives::Cint) +function SCIPfreeRepresentation(scip, representatives, nrepresentatives) ccall((:SCIPfreeRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) end -function SCIPapplyReopt(scip, reoptnode, id::UInt32, estimate::Cdouble, childnodes, ncreatedchilds, naddedconss, childnodessize::Cint, success) +function SCIPapplyReopt(scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) ccall((:SCIPapplyReopt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, UInt32, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{UInt32}), scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) end @@ -70,10 +70,10 @@ function SCIPdeleteReoptnode(scip, reoptnode) ccall((:SCIPdeleteReoptnode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}), scip, reoptnode) end -function SCIPgetReoptSimilarity(scip, run1::Cint, run2::Cint) +function SCIPgetReoptSimilarity(scip, run1, run2) ccall((:SCIPgetReoptSimilarity, libscip), Cdouble, (Ptr{SCIP}, Cint, Cint), scip, run1, run2) end -function SCIPgetVarCoefChg(scip, varidx::Cint, negated, entering, leaving) +function SCIPgetVarCoefChg(scip, varidx, negated, entering, leaving) ccall((:SCIPgetVarCoefChg, libscip), Cvoid, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, varidx, negated, entering, leaving) end diff --git a/src/wrapper/scip_sepa.jl b/src/wrapper/scip_sepa.jl index cc94cfc1..aa0d53ab 100644 --- a/src/wrapper/scip_sepa.jl +++ b/src/wrapper/scip_sepa.jl @@ -1,12 +1,12 @@ # Julia wrapper for header: /usr/include/scip/scip_sepa.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeSepa(scip, name, desc, priority::Cint, freq::Cint, maxbounddist::Cdouble, usessubscip::UInt32, delay::UInt32, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) +function SCIPincludeSepa(scip, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) ccall((:SCIPincludeSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) end -function SCIPincludeSepaBasic(scip, sepa, name, desc, priority::Cint, freq::Cint, maxbounddist::Cdouble, usessubscip::UInt32, delay::UInt32, sepaexeclp, sepaexecsol, sepadata) +function SCIPincludeSepaBasic(scip, sepa, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepaexeclp, sepaexecsol, sepadata) ccall((:SCIPincludeSepaBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SEPA}}, Cstring, Cstring, Cint, Cint, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, sepa, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepaexeclp, sepaexecsol, sepadata) end @@ -46,7 +46,7 @@ function SCIPgetNSepas(scip) ccall((:SCIPgetNSepas, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPsetSepaPriority(scip, sepa, priority::Cint) +function SCIPsetSepaPriority(scip, sepa, priority) ccall((:SCIPsetSepaPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Cint), scip, sepa, priority) end diff --git a/src/wrapper/scip_sol.jl b/src/wrapper/scip_sol.jl index 8ea6d050..3c2c09e8 100644 --- a/src/wrapper/scip_sol.jl +++ b/src/wrapper/scip_sol.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_sol.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPcreateSol(scip, sol, heur) @@ -82,15 +82,15 @@ function SCIPunlinkSol(scip, sol) ccall((:SCIPunlinkSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end -function SCIPsetSolVal(scip, sol, var, val::Cdouble) +function SCIPsetSolVal(scip, sol, var, val) ccall((:SCIPsetSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, val) end -function SCIPsetSolVals(scip, sol, nvars::Cint, vars, vals) +function SCIPsetSolVals(scip, sol, nvars, vars, vals) ccall((:SCIPsetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) end -function SCIPincSolVal(scip, sol, var, incval::Cdouble) +function SCIPincSolVal(scip, sol, var, incval) ccall((:SCIPincSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, incval) end @@ -98,7 +98,7 @@ function SCIPgetSolVal(scip, sol, var) ccall((:SCIPgetSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}), scip, sol, var) end -function SCIPgetSolVals(scip, sol, nvars::Cint, vars, vals) +function SCIPgetSolVals(scip, sol, nvars, vars, vals) ccall((:SCIPgetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) end @@ -114,11 +114,11 @@ function SCIPrecomputeSolObj(scip, sol) ccall((:SCIPrecomputeSolObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end -function SCIPtransformObj(scip, obj::Cdouble) +function SCIPtransformObj(scip, obj) ccall((:SCIPtransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) end -function SCIPretransformObj(scip, obj::Cdouble) +function SCIPretransformObj(scip, obj) ccall((:SCIPretransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) end @@ -142,15 +142,15 @@ function SCIPareSolsEqual(scip, sol1, sol2) ccall((:SCIPareSolsEqual, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_SOL}), scip, sol1, sol2) end -function SCIPadjustImplicitSolVals(scip, sol, uselprows::UInt32) +function SCIPadjustImplicitSolVals(scip, sol, uselprows) ccall((:SCIPadjustImplicitSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32), scip, sol, uselprows) end -function SCIPprintSol(scip, sol, file, printzeros::UInt32) +function SCIPprintSol(scip, sol, file, printzeros) ccall((:SCIPprintSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) end -function SCIPprintTransSol(scip, sol, file, printzeros::UInt32) +function SCIPprintTransSol(scip, sol, file, printzeros) ccall((:SCIPprintTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) end @@ -162,15 +162,15 @@ function SCIPgetDualSolVal(scip, cons, dualsolval, boundconstraint) ccall((:SCIPgetDualSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{UInt32}), scip, cons, dualsolval, boundconstraint) end -function SCIPisDualSolAvailable(scip, printreason::UInt32) +function SCIPisDualSolAvailable(scip, printreason) ccall((:SCIPisDualSolAvailable, libscip), UInt32, (Ptr{SCIP}, UInt32), scip, printreason) end -function SCIPprintDualSol(scip, file, printzeros::UInt32) +function SCIPprintDualSol(scip, file, printzeros) ccall((:SCIPprintDualSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) end -function SCIPprintRay(scip, sol, file, printzeros::UInt32) +function SCIPprintRay(scip, sol, file, printzeros) ccall((:SCIPprintRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) end @@ -186,11 +186,11 @@ function SCIPgetBestSol(scip) ccall((:SCIPgetBestSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP},), scip) end -function SCIPprintBestSol(scip, file, printzeros::UInt32) +function SCIPprintBestSol(scip, file, printzeros) ccall((:SCIPprintBestSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) end -function SCIPprintBestTransSol(scip, file, printzeros::UInt32) +function SCIPprintBestTransSol(scip, file, printzeros) ccall((:SCIPprintBestTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) end @@ -206,7 +206,7 @@ function SCIPreadSol(scip, filename) ccall((:SCIPreadSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) end -function SCIPreadSolFile(scip, filename, sol, xml::UInt32, partial, error) +function SCIPreadSolFile(scip, filename, sol, xml, partial, error) ccall((:SCIPreadSolFile, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{SCIP_SOL}, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, filename, sol, xml, partial, error) end @@ -222,15 +222,15 @@ function SCIPaddCurrentSol(scip, heur, stored) ccall((:SCIPaddCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{UInt32}), scip, heur, stored) end -function SCIPtrySol(scip, sol, printreason::UInt32, completely::UInt32, checkbounds::UInt32, checkintegrality::UInt32, checklprows::UInt32, stored) +function SCIPtrySol(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) ccall((:SCIPtrySol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) end -function SCIPtrySolFree(scip, sol, printreason::UInt32, completely::UInt32, checkbounds::UInt32, checkintegrality::UInt32, checklprows::UInt32, stored) +function SCIPtrySolFree(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) ccall((:SCIPtrySolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) end -function SCIPtryCurrentSol(scip, heur, printreason::UInt32, completely::UInt32, checkintegrality::UInt32, checklprows::UInt32, stored) +function SCIPtryCurrentSol(scip, heur, printreason, completely, checkintegrality, checklprows, stored) ccall((:SCIPtryCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, heur, printreason, completely, checkintegrality, checklprows, stored) end @@ -242,31 +242,31 @@ function SCIPgetNPartialSols(scip) ccall((:SCIPgetNPartialSols, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPcheckSol(scip, sol, printreason::UInt32, completely::UInt32, checkbounds::UInt32, checkintegrality::UInt32, checklprows::UInt32, feasible) +function SCIPcheckSol(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) ccall((:SCIPcheckSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) end -function SCIPcheckSolOrig(scip, sol, feasible, printreason::UInt32, completely::UInt32) +function SCIPcheckSolOrig(scip, sol, feasible, printreason, completely) ccall((:SCIPcheckSolOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{UInt32}, UInt32, UInt32), scip, sol, feasible, printreason, completely) end -function SCIPupdateSolIntegralityViolation(scip, sol, absviol::Cdouble) +function SCIPupdateSolIntegralityViolation(scip, sol, absviol) ccall((:SCIPupdateSolIntegralityViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble), scip, sol, absviol) end -function SCIPupdateSolBoundViolation(scip, sol, absviol::Cdouble, relviol::Cdouble) +function SCIPupdateSolBoundViolation(scip, sol, absviol, relviol) ccall((:SCIPupdateSolBoundViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end -function SCIPupdateSolLPRowViolation(scip, sol, absviol::Cdouble, relviol::Cdouble) +function SCIPupdateSolLPRowViolation(scip, sol, absviol, relviol) ccall((:SCIPupdateSolLPRowViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end -function SCIPupdateSolConsViolation(scip, sol, absviol::Cdouble, relviol::Cdouble) +function SCIPupdateSolConsViolation(scip, sol, absviol, relviol) ccall((:SCIPupdateSolConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end -function SCIPupdateSolLPConsViolation(scip, sol, absviol::Cdouble, relviol::Cdouble) +function SCIPupdateSolLPConsViolation(scip, sol, absviol, relviol) ccall((:SCIPupdateSolLPConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end diff --git a/src/wrapper/scip_solve.jl b/src/wrapper/scip_solve.jl index 5990130c..412770d9 100644 --- a/src/wrapper/scip_solve.jl +++ b/src/wrapper/scip_solve.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_solve.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPtransformProb(scip) @@ -22,7 +22,7 @@ function SCIPsolveConcurrent(scip) ccall((:SCIPsolveConcurrent, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPfreeSolve(scip, restart::UInt32) +function SCIPfreeSolve(scip, restart) ccall((:SCIPfreeSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, restart) end @@ -42,7 +42,7 @@ function SCIPrestartSolve(scip) ccall((:SCIPrestartSolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPenableReoptimization(scip, enable::UInt32) +function SCIPenableReoptimization(scip, enable) ccall((:SCIPenableReoptimization, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, enable) end @@ -50,7 +50,7 @@ function SCIPisReoptEnabled(scip) ccall((:SCIPisReoptEnabled, libscip), UInt32, (Ptr{SCIP},), scip) end -function SCIPgetReoptSolsRun(scip, run::Cint, sols, allocmem::Cint, nsols) +function SCIPgetReoptSolsRun(scip, run, sols, allocmem, nsols) ccall((:SCIPgetReoptSolsRun, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_SOL}}, Cint, Ptr{Cint}), scip, run, sols, allocmem, nsols) end @@ -62,7 +62,7 @@ function SCIPcheckReoptRestart(scip, node, restart) ccall((:SCIPcheckReoptRestart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}), scip, node, restart) end -function SCIPaddReoptDualBndchg(scip, node, var, newbound::Cdouble, oldbound::Cdouble) +function SCIPaddReoptDualBndchg(scip, node, var, newbound, oldbound) ccall((:SCIPaddReoptDualBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, node, var, newbound, oldbound) end @@ -70,7 +70,7 @@ function SCIPgetReoptLastOptSol(scip) ccall((:SCIPgetReoptLastOptSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP},), scip) end -function SCIPgetReoptOldObjCoef(scip, var, run::Cint, objcoef) +function SCIPgetReoptOldObjCoef(scip, var, run, objcoef) ccall((:SCIPgetReoptOldObjCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, run, objcoef) end diff --git a/src/wrapper/scip_solvingstats.jl b/src/wrapper/scip_solvingstats.jl index c1f28c06..2b7cc9b9 100644 --- a/src/wrapper/scip_solvingstats.jl +++ b/src/wrapper/scip_solvingstats.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_solvingstats.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPgetNRuns(scip) @@ -10,7 +10,7 @@ function SCIPgetNReoptRuns(scip) ccall((:SCIPgetNReoptRuns, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPaddNNodes(scip, nnodes::Clonglong) +function SCIPaddNNodes(scip, nnodes) ccall((:SCIPaddNNodes, libscip), Cvoid, (Ptr{SCIP}, Clonglong), scip, nnodes) end @@ -258,7 +258,7 @@ function SCIPgetCutoffbound(scip) ccall((:SCIPgetCutoffbound, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPupdateCutoffbound(scip, cutoffbound::Cdouble) +function SCIPupdateCutoffbound(scip, cutoffbound) ccall((:SCIPupdateCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, cutoffbound) end @@ -286,23 +286,23 @@ function SCIPgetNBestSolsFound(scip) ccall((:SCIPgetNBestSolsFound, libscip), Clonglong, (Ptr{SCIP},), scip) end -function SCIPgetAvgPseudocost(scip, solvaldelta::Cdouble) +function SCIPgetAvgPseudocost(scip, solvaldelta) ccall((:SCIPgetAvgPseudocost, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) end -function SCIPgetAvgPseudocostCurrentRun(scip, solvaldelta::Cdouble) +function SCIPgetAvgPseudocostCurrentRun(scip, solvaldelta) ccall((:SCIPgetAvgPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) end -function SCIPgetAvgPseudocostCount(scip, dir::SCIP_BRANCHDIR) +function SCIPgetAvgPseudocostCount(scip, dir) ccall((:SCIPgetAvgPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end -function SCIPgetAvgPseudocostCountCurrentRun(scip, dir::SCIP_BRANCHDIR) +function SCIPgetAvgPseudocostCountCurrentRun(scip, dir) ccall((:SCIPgetAvgPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end -function SCIPgetPseudocostCount(scip, dir::SCIP_BRANCHDIR, onlycurrentrun::UInt32) +function SCIPgetPseudocostCount(scip, dir, onlycurrentrun) ccall((:SCIPgetPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, UInt32), scip, dir, onlycurrentrun) end @@ -310,7 +310,7 @@ function SCIPgetAvgPseudocostScore(scip) ccall((:SCIPgetAvgPseudocostScore, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPgetPseudocostVariance(scip, branchdir::SCIP_BRANCHDIR, onlycurrentrun::UInt32) +function SCIPgetPseudocostVariance(scip, branchdir, onlycurrentrun) ccall((:SCIPgetPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, UInt32), scip, branchdir, onlycurrentrun) end @@ -334,11 +334,11 @@ function SCIPgetAvgConflictlengthScoreCurrentRun(scip) ccall((:SCIPgetAvgConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPgetAvgInferences(scip, dir::SCIP_BRANCHDIR) +function SCIPgetAvgInferences(scip, dir) ccall((:SCIPgetAvgInferences, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end -function SCIPgetAvgInferencesCurrentRun(scip, dir::SCIP_BRANCHDIR) +function SCIPgetAvgInferencesCurrentRun(scip, dir) ccall((:SCIPgetAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end @@ -350,11 +350,11 @@ function SCIPgetAvgInferenceScoreCurrentRun(scip) ccall((:SCIPgetAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPgetAvgCutoffs(scip, dir::SCIP_BRANCHDIR) +function SCIPgetAvgCutoffs(scip, dir) ccall((:SCIPgetAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end -function SCIPgetAvgCutoffsCurrentRun(scip, dir::SCIP_BRANCHDIR) +function SCIPgetAvgCutoffsCurrentRun(scip, dir) ccall((:SCIPgetAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end @@ -370,11 +370,11 @@ function SCIPgetDeterministicTime(scip) ccall((:SCIPgetDeterministicTime, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPprintOrigProblem(scip, file, extension, genericnames::UInt32) +function SCIPprintOrigProblem(scip, file, extension, genericnames) ccall((:SCIPprintOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Cstring, UInt32), scip, file, extension, genericnames) end -function SCIPprintTransProblem(scip, file, extension, genericnames::UInt32) +function SCIPprintTransProblem(scip, file, extension, genericnames) ccall((:SCIPprintTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Cstring, UInt32), scip, file, extension, genericnames) end @@ -478,7 +478,7 @@ function SCIPprintBranchingStatistics(scip, file) ccall((:SCIPprintBranchingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) end -function SCIPprintDisplayLine(scip, file, verblevel::SCIP_VERBLEVEL, endline::UInt32) +function SCIPprintDisplayLine(scip, file, verblevel, endline) ccall((:SCIPprintDisplayLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, SCIP_VERBLEVEL, UInt32), scip, file, verblevel, endline) end diff --git a/src/wrapper/scip_table.jl b/src/wrapper/scip_table.jl index 7b99ab42..d257b8d9 100644 --- a/src/wrapper/scip_table.jl +++ b/src/wrapper/scip_table.jl @@ -1,8 +1,8 @@ # Julia wrapper for header: /usr/include/scip/scip_table.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPincludeTable(scip, name, desc, active::UInt32, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tabledata, position::Cint, earlieststage::SCIP_STAGE) +function SCIPincludeTable(scip, name, desc, active, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tabledata, position, earlieststage) ccall((:SCIPincludeTable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_TABLEDATA}, Cint, SCIP_STAGE), scip, name, desc, active, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tabledata, position, earlieststage) end diff --git a/src/wrapper/scip_timing.jl b/src/wrapper/scip_timing.jl index 6364e8ec..25548d56 100644 --- a/src/wrapper/scip_timing.jl +++ b/src/wrapper/scip_timing.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_timing.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPgetTimeOfDay(scip) @@ -50,7 +50,7 @@ function SCIPgetClockTime(scip, clck) ccall((:SCIPgetClockTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) end -function SCIPsetClockTime(scip, clck, sec::Cdouble) +function SCIPsetClockTime(scip, clck, sec) ccall((:SCIPsetClockTime, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}, Cdouble), scip, clck, sec) end diff --git a/src/wrapper/scip_tree.jl b/src/wrapper/scip_tree.jl index 399b2dea..cebf5fe2 100644 --- a/src/wrapper/scip_tree.jl +++ b/src/wrapper/scip_tree.jl @@ -1,5 +1,5 @@ # Julia wrapper for header: /usr/include/scip/scip_tree.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c function SCIPgetFocusNode(scip) @@ -114,6 +114,6 @@ function SCIPprintNodeRootPath(scip, node, file) ccall((:SCIPprintNodeRootPath, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{FILE}), scip, node, file) end -function SCIPsetFocusnodeLP(scip, solvelp::UInt32) +function SCIPsetFocusnodeLP(scip, solvelp) ccall((:SCIPsetFocusnodeLP, libscip), Cvoid, (Ptr{SCIP}, UInt32), scip, solvelp) end diff --git a/src/wrapper/scip_validation.jl b/src/wrapper/scip_validation.jl index fc191152..0258b24e 100644 --- a/src/wrapper/scip_validation.jl +++ b/src/wrapper/scip_validation.jl @@ -1,7 +1,7 @@ # Julia wrapper for header: /usr/include/scip/scip_validation.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPvalidateSolve(scip, primalreference::Cdouble, dualreference::Cdouble, reftol::Cdouble, quiet::UInt32, feasible, primalboundcheck, dualboundcheck) +function SCIPvalidateSolve(scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) ccall((:SCIPvalidateSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) end diff --git a/src/wrapper/scip_var.jl b/src/wrapper/scip_var.jl index 439a6c6e..90f2dc54 100644 --- a/src/wrapper/scip_var.jl +++ b/src/wrapper/scip_var.jl @@ -1,32 +1,32 @@ # Julia wrapper for header: /usr/include/scip/scip_var.h -# Automatically generated using Clang.jl wrap_c, version 0.0.0 +# Automatically generated using Clang.jl wrap_c -function SCIPcreateVar(scip, var, name, lb::Cdouble, ub::Cdouble, obj::Cdouble, vartype::SCIP_VARTYPE, initial::UInt32, removable::UInt32, vardelorig, vartrans, vardeltrans, varcopy, vardata) +function SCIPcreateVar(scip, var, name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) ccall((:SCIPcreateVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}), scip, var, name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) end -function SCIPcreateVarBasic(scip, var, name, lb::Cdouble, ub::Cdouble, obj::Cdouble, vartype::SCIP_VARTYPE) +function SCIPcreateVarBasic(scip, var, name, lb, ub, obj, vartype) ccall((:SCIPcreateVarBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE), scip, var, name, lb, ub, obj, vartype) end -function SCIPwriteVarName(scip, file, var, type::UInt32) +function SCIPwriteVarName(scip, file, var, type) ccall((:SCIPwriteVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{SCIP_VAR}, UInt32), scip, file, var, type) end -function SCIPwriteVarsList(scip, file, vars, nvars::Cint, type::UInt32, delimiter::UInt8) +function SCIPwriteVarsList(scip, file, vars, nvars, type, delimiter) ccall((:SCIPwriteVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt8), scip, file, vars, nvars, type, delimiter) end -function SCIPwriteVarsLinearsum(scip, file, vars, vals, nvars::Cint, type::UInt32) +function SCIPwriteVarsLinearsum(scip, file, vars, vals, nvars, type) ccall((:SCIPwriteVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), scip, file, vars, vals, nvars, type) end -function SCIPwriteVarsPolynomial(scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials::Cint, type::UInt32) +function SCIPwriteVarsPolynomial(scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, type) ccall((:SCIPwriteVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}, Cint, UInt32), scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, type) end -function SCIPparseVar(scip, var, str, initial::UInt32, removable::UInt32, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) +function SCIPparseVar(scip, var, str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) ccall((:SCIPparseVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}, Ptr{Cstring}, Ptr{UInt32}), scip, var, str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) end @@ -34,11 +34,11 @@ function SCIPparseVarName(scip, str, var, endptr) ccall((:SCIPparseVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cstring}), scip, str, var, endptr) end -function SCIPparseVarsList(scip, str, vars, nvars, varssize::Cint, requiredsize, endptr, delimiter::UInt8, success) +function SCIPparseVarsList(scip, str, vars, nvars, varssize, requiredsize, endptr, delimiter, success) ccall((:SCIPparseVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cstring}, UInt8, Ptr{UInt32}), scip, str, vars, nvars, varssize, requiredsize, endptr, delimiter, success) end -function SCIPparseVarsLinearsum(scip, str, vars, vals, nvars, varssize::Cint, requiredsize, endptr, success) +function SCIPparseVarsLinearsum(scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) ccall((:SCIPparseVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cstring}, Ptr{UInt32}), scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) end @@ -46,7 +46,7 @@ function SCIPparseVarsPolynomial(scip, str, monomialvars, monomialexps, monomial ccall((:SCIPparseVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cstring}, Ptr{UInt32}), scip, str, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, endptr, success) end -function SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials::Cint) +function SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials) ccall((:SCIPfreeParseVarsPolynomialData, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Cint), scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials) end @@ -66,7 +66,7 @@ function SCIPtransformVar(scip, var, transvar) ccall((:SCIPtransformVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) end -function SCIPtransformVars(scip, nvars::Cint, vars, transvars) +function SCIPtransformVars(scip, nvars, vars, transvars) ccall((:SCIPtransformVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) end @@ -74,7 +74,7 @@ function SCIPgetTransformedVar(scip, var, transvar) ccall((:SCIPgetTransformedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) end -function SCIPgetTransformedVars(scip, nvars::Cint, vars, transvars) +function SCIPgetTransformedVars(scip, nvars, vars, transvars) ccall((:SCIPgetTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) end @@ -82,7 +82,7 @@ function SCIPgetNegatedVar(scip, var, negvar) ccall((:SCIPgetNegatedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, negvar) end -function SCIPgetNegatedVars(scip, nvars::Cint, vars, negvars) +function SCIPgetNegatedVars(scip, nvars, vars, negvars) ccall((:SCIPgetNegatedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, negvars) end @@ -90,7 +90,7 @@ function SCIPgetBinvarRepresentative(scip, var, repvar, negated) ccall((:SCIPgetBinvarRepresentative, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), scip, var, repvar, negated) end -function SCIPgetBinvarRepresentatives(scip, nvars::Cint, vars, repvars, negated) +function SCIPgetBinvarRepresentatives(scip, nvars, vars, repvars, negated) ccall((:SCIPgetBinvarRepresentatives, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), scip, nvars, vars, repvars, negated) end @@ -98,7 +98,7 @@ function SCIPflattenVarAggregationGraph(scip, var) ccall((:SCIPflattenVarAggregationGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPgetProbvarLinearSum(scip, vars, scalars, nvars, varssize::Cint, constant, requiredsize, mergemultiples::UInt32) +function SCIPgetProbvarLinearSum(scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) ccall((:SCIPgetProbvarLinearSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cdouble}, Ptr{Cint}, UInt32), scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) end @@ -106,7 +106,7 @@ function SCIPgetProbvarSum(scip, var, scalar, constant) ccall((:SCIPgetProbvarSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, scalar, constant) end -function SCIPgetActiveVars(scip, vars, nvars, varssize::Cint, requiredsize) +function SCIPgetActiveVars(scip, vars, nvars, varssize, requiredsize) ccall((:SCIPgetActiveVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}), scip, vars, nvars, varssize, requiredsize) end @@ -114,7 +114,7 @@ function SCIPgetVarRedcost(scip, var) ccall((:SCIPgetVarRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPgetVarImplRedcost(scip, var, varfixing::UInt32) +function SCIPgetVarImplRedcost(scip, var, varfixing) ccall((:SCIPgetVarImplRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32), scip, var, varfixing) end @@ -122,19 +122,19 @@ function SCIPgetVarFarkasCoef(scip, var) ccall((:SCIPgetVarFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPgetVarLbAtIndex(scip, var, bdchgidx, after::UInt32) +function SCIPgetVarLbAtIndex(scip, var, bdchgidx, after) ccall((:SCIPgetVarLbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) end -function SCIPgetVarUbAtIndex(scip, var, bdchgidx, after::UInt32) +function SCIPgetVarUbAtIndex(scip, var, bdchgidx, after) ccall((:SCIPgetVarUbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) end -function SCIPgetVarBdAtIndex(scip, var, boundtype::SCIP_BOUNDTYPE, bdchgidx, after::UInt32) +function SCIPgetVarBdAtIndex(scip, var, boundtype, bdchgidx, after) ccall((:SCIPgetVarBdAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, boundtype, bdchgidx, after) end -function SCIPgetVarWasFixedAtIndex(scip, var, bdchgidx, after::UInt32) +function SCIPgetVarWasFixedAtIndex(scip, var, bdchgidx, after) ccall((:SCIPgetVarWasFixedAtIndex, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) end @@ -142,7 +142,7 @@ function SCIPgetVarSol(scip, var) ccall((:SCIPgetVarSol, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPgetVarSols(scip, nvars::Cint, vars, vals) +function SCIPgetVarSols(scip, nvars, vars, vals) ccall((:SCIPgetVarSols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nvars, vars, vals) end @@ -150,15 +150,15 @@ function SCIPclearRelaxSolVals(scip) ccall((:SCIPclearRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPsetRelaxSolVal(scip, var, val::Cdouble) +function SCIPsetRelaxSolVal(scip, var, val) ccall((:SCIPsetRelaxSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, val) end -function SCIPsetRelaxSolVals(scip, nvars::Cint, vars, vals, includeslp::UInt32) +function SCIPsetRelaxSolVals(scip, nvars, vars, vals, includeslp) ccall((:SCIPsetRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, UInt32), scip, nvars, vars, vals, includeslp) end -function SCIPsetRelaxSolValsSol(scip, sol, includeslp::UInt32) +function SCIPsetRelaxSolValsSol(scip, sol, includeslp) ccall((:SCIPsetRelaxSolValsSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32), scip, sol, includeslp) end @@ -166,7 +166,7 @@ function SCIPisRelaxSolValid(scip) ccall((:SCIPisRelaxSolValid, libscip), UInt32, (Ptr{SCIP},), scip) end -function SCIPmarkRelaxSolValid(scip, includeslp::UInt32) +function SCIPmarkRelaxSolValid(scip, includeslp) ccall((:SCIPmarkRelaxSolValid, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, includeslp) end @@ -186,7 +186,7 @@ function SCIPisStrongbranchDownFirst(scip, var) ccall((:SCIPisStrongbranchDownFirst, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPstartStrongbranch(scip, enablepropagation::UInt32) +function SCIPstartStrongbranch(scip, enablepropagation) ccall((:SCIPstartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, enablepropagation) end @@ -194,27 +194,27 @@ function SCIPendStrongbranch(scip) ccall((:SCIPendStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPgetVarStrongbranchFrac(scip, var, itlim::Cint, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +function SCIPgetVarStrongbranchFrac(scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) ccall((:SCIPgetVarStrongbranchFrac, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) end -function SCIPgetVarStrongbranchWithPropagation(scip, var, solval::Cdouble, lpobjval::Cdouble, itlim::Cint, maxproprounds::Cint, down, up, downvalid, upvalid, ndomredsdown, ndomredsup, downinf, upinf, downconflict, upconflict, lperror, newlbs, newubs) +function SCIPgetVarStrongbranchWithPropagation(scip, var, solval, lpobjval, itlim, maxproprounds, down, up, downvalid, upvalid, ndomredsdown, ndomredsup, downinf, upinf, downconflict, upconflict, lperror, newlbs, newubs) ccall((:SCIPgetVarStrongbranchWithPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Clonglong}, Ptr{Clonglong}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, solval, lpobjval, itlim, maxproprounds, down, up, downvalid, upvalid, ndomredsdown, ndomredsup, downinf, upinf, downconflict, upconflict, lperror, newlbs, newubs) end -function SCIPgetVarStrongbranchInt(scip, var, itlim::Cint, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +function SCIPgetVarStrongbranchInt(scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) ccall((:SCIPgetVarStrongbranchInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) end -function SCIPgetVarsStrongbranchesFrac(scip, vars, nvars::Cint, itlim::Cint, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +function SCIPgetVarsStrongbranchesFrac(scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) ccall((:SCIPgetVarsStrongbranchesFrac, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) end -function SCIPgetVarsStrongbranchesInt(scip, vars, nvars::Cint, itlim::Cint, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +function SCIPgetVarsStrongbranchesInt(scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) ccall((:SCIPgetVarsStrongbranchesInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) end -function SCIPgetLastStrongbranchLPSolStat(scip, branchdir::SCIP_BRANCHDIR) +function SCIPgetLastStrongbranchLPSolStat(scip, branchdir) ccall((:SCIPgetLastStrongbranchLPSolStat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, branchdir) end @@ -222,7 +222,7 @@ function SCIPgetVarStrongbranchLast(scip, var, down, up, downvalid, upvalid, sol ccall((:SCIPgetVarStrongbranchLast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, down, up, downvalid, upvalid, solval, lpobjval) end -function SCIPsetVarStrongbranchData(scip, var, lpobjval::Cdouble, primsol::Cdouble, down::Cdouble, up::Cdouble, downvalid::UInt32, upvalid::UInt32, iter::Clonglong, itlim::Cint) +function SCIPsetVarStrongbranchData(scip, var, lpobjval, primsol, down, up, downvalid, upvalid, iter, itlim) ccall((:SCIPsetVarStrongbranchData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, UInt32, Clonglong, Cint), scip, var, lpobjval, primsol, down, up, downvalid, upvalid, iter, itlim) end @@ -242,115 +242,115 @@ function SCIPgetVarNStrongbranchs(scip, var) ccall((:SCIPgetVarNStrongbranchs, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPaddVarLocksType(scip, var, locktype::SCIP_LOCKTYPE, nlocksdown::Cint, nlocksup::Cint) +function SCIPaddVarLocksType(scip, var, locktype, nlocksdown, nlocksup) ccall((:SCIPaddVarLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_LOCKTYPE, Cint, Cint), scip, var, locktype, nlocksdown, nlocksup) end -function SCIPaddVarLocks(scip, var, nlocksdown::Cint, nlocksup::Cint) +function SCIPaddVarLocks(scip, var, nlocksdown, nlocksup) ccall((:SCIPaddVarLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cint), scip, var, nlocksdown, nlocksup) end -function SCIPlockVarCons(scip, var, cons, lockdown::UInt32, lockup::UInt32) +function SCIPlockVarCons(scip, var, cons, lockdown, lockup) ccall((:SCIPlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32), scip, var, cons, lockdown, lockup) end -function SCIPunlockVarCons(scip, var, cons, lockdown::UInt32, lockup::UInt32) +function SCIPunlockVarCons(scip, var, cons, lockdown, lockup) ccall((:SCIPunlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32), scip, var, cons, lockdown, lockup) end -function SCIPchgVarObj(scip, var, newobj::Cdouble) +function SCIPchgVarObj(scip, var, newobj) ccall((:SCIPchgVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end -function SCIPaddVarObj(scip, var, addobj::Cdouble) +function SCIPaddVarObj(scip, var, addobj) ccall((:SCIPaddVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addobj) end -function SCIPadjustedVarLb(scip, var, lb::Cdouble) +function SCIPadjustedVarLb(scip, var, lb) ccall((:SCIPadjustedVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lb) end -function SCIPadjustedVarUb(scip, var, ub::Cdouble) +function SCIPadjustedVarUb(scip, var, ub) ccall((:SCIPadjustedVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, ub) end -function SCIPchgVarLb(scip, var, newbound::Cdouble) +function SCIPchgVarLb(scip, var, newbound) ccall((:SCIPchgVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end -function SCIPchgVarUb(scip, var, newbound::Cdouble) +function SCIPchgVarUb(scip, var, newbound) ccall((:SCIPchgVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end -function SCIPchgVarLbNode(scip, node, var, newbound::Cdouble) +function SCIPchgVarLbNode(scip, node, var, newbound) ccall((:SCIPchgVarLbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) end -function SCIPchgVarUbNode(scip, node, var, newbound::Cdouble) +function SCIPchgVarUbNode(scip, node, var, newbound) ccall((:SCIPchgVarUbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) end -function SCIPchgVarLbGlobal(scip, var, newbound::Cdouble) +function SCIPchgVarLbGlobal(scip, var, newbound) ccall((:SCIPchgVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end -function SCIPchgVarUbGlobal(scip, var, newbound::Cdouble) +function SCIPchgVarUbGlobal(scip, var, newbound) ccall((:SCIPchgVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end -function SCIPchgVarLbLazy(scip, var, lazylb::Cdouble) +function SCIPchgVarLbLazy(scip, var, lazylb) ccall((:SCIPchgVarLbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazylb) end -function SCIPchgVarUbLazy(scip, var, lazyub::Cdouble) +function SCIPchgVarUbLazy(scip, var, lazyub) ccall((:SCIPchgVarUbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazyub) end -function SCIPtightenVarLb(scip, var, newbound::Cdouble, force::UInt32, infeasible, tightened) +function SCIPtightenVarLb(scip, var, newbound, force, infeasible, tightened) ccall((:SCIPtightenVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) end -function SCIPtightenVarUb(scip, var, newbound::Cdouble, force::UInt32, infeasible, tightened) +function SCIPtightenVarUb(scip, var, newbound, force, infeasible, tightened) ccall((:SCIPtightenVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) end -function SCIPinferVarFixCons(scip, var, fixedval::Cdouble, infercons, inferinfo::Cint, force::UInt32, infeasible, tightened) +function SCIPinferVarFixCons(scip, var, fixedval, infercons, inferinfo, force, infeasible, tightened) ccall((:SCIPinferVarFixCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infercons, inferinfo, force, infeasible, tightened) end -function SCIPinferVarLbCons(scip, var, newbound::Cdouble, infercons, inferinfo::Cint, force::UInt32, infeasible, tightened) +function SCIPinferVarLbCons(scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) ccall((:SCIPinferVarLbCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) end -function SCIPinferVarUbCons(scip, var, newbound::Cdouble, infercons, inferinfo::Cint, force::UInt32, infeasible, tightened) +function SCIPinferVarUbCons(scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) ccall((:SCIPinferVarUbCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) end -function SCIPinferBinvarCons(scip, var, fixedval::UInt32, infercons, inferinfo::Cint, infeasible, tightened) +function SCIPinferBinvarCons(scip, var, fixedval, infercons, inferinfo, infeasible, tightened) ccall((:SCIPinferBinvarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_CONS}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infercons, inferinfo, infeasible, tightened) end -function SCIPinferVarFixProp(scip, var, fixedval::Cdouble, inferprop, inferinfo::Cint, force::UInt32, infeasible, tightened) +function SCIPinferVarFixProp(scip, var, fixedval, inferprop, inferinfo, force, infeasible, tightened) ccall((:SCIPinferVarFixProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, inferprop, inferinfo, force, infeasible, tightened) end -function SCIPinferVarLbProp(scip, var, newbound::Cdouble, inferprop, inferinfo::Cint, force::UInt32, infeasible, tightened) +function SCIPinferVarLbProp(scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) ccall((:SCIPinferVarLbProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) end -function SCIPinferVarUbProp(scip, var, newbound::Cdouble, inferprop, inferinfo::Cint, force::UInt32, infeasible, tightened) +function SCIPinferVarUbProp(scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) ccall((:SCIPinferVarUbProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) end -function SCIPinferBinvarProp(scip, var, fixedval::UInt32, inferprop, inferinfo::Cint, infeasible, tightened) +function SCIPinferBinvarProp(scip, var, fixedval, inferprop, inferinfo, infeasible, tightened) ccall((:SCIPinferBinvarProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_PROP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, inferprop, inferinfo, infeasible, tightened) end -function SCIPtightenVarLbGlobal(scip, var, newbound::Cdouble, force::UInt32, infeasible, tightened) +function SCIPtightenVarLbGlobal(scip, var, newbound, force, infeasible, tightened) ccall((:SCIPtightenVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) end -function SCIPtightenVarUbGlobal(scip, var, newbound::Cdouble, force::UInt32, infeasible, tightened) +function SCIPtightenVarUbGlobal(scip, var, newbound, force, infeasible, tightened) ccall((:SCIPtightenVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) end @@ -394,27 +394,27 @@ function SCIPgetVarClosestVub(scip, var, sol, closestvub, closestvubidx) ccall((:SCIPgetVarClosestVub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvub, closestvubidx) end -function SCIPaddVarVlb(scip, var, vlbvar, vlbcoef::Cdouble, vlbconstant::Cdouble, infeasible, nbdchgs) +function SCIPaddVarVlb(scip, var, vlbvar, vlbcoef, vlbconstant, infeasible, nbdchgs) ccall((:SCIPaddVarVlb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, vlbvar, vlbcoef, vlbconstant, infeasible, nbdchgs) end -function SCIPaddVarVub(scip, var, vubvar, vubcoef::Cdouble, vubconstant::Cdouble, infeasible, nbdchgs) +function SCIPaddVarVub(scip, var, vubvar, vubcoef, vubconstant, infeasible, nbdchgs) ccall((:SCIPaddVarVub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, vubvar, vubcoef, vubconstant, infeasible, nbdchgs) end -function SCIPaddVarImplication(scip, var, varfixing::UInt32, implvar, impltype::SCIP_BOUNDTYPE, implbound::Cdouble, infeasible, nbdchgs) +function SCIPaddVarImplication(scip, var, varfixing, implvar, impltype, implbound, infeasible, nbdchgs) ccall((:SCIPaddVarImplication, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, varfixing, implvar, impltype, implbound, infeasible, nbdchgs) end -function SCIPaddClique(scip, vars, values, nvars::Cint, isequation::UInt32, infeasible, nbdchgs) +function SCIPaddClique(scip, vars, values, nvars, isequation, infeasible, nbdchgs) ccall((:SCIPaddClique, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}, Cint, UInt32, Ptr{UInt32}, Ptr{Cint}), scip, vars, values, nvars, isequation, infeasible, nbdchgs) end -function SCIPcalcCliquePartition(scip, vars, nvars::Cint, cliquepartition, ncliques) +function SCIPcalcCliquePartition(scip, vars, nvars, cliquepartition, ncliques) ccall((:SCIPcalcCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, cliquepartition, ncliques) end -function SCIPcalcNegatedCliquePartition(scip, vars, nvars::Cint, cliquepartition, ncliques) +function SCIPcalcNegatedCliquePartition(scip, vars, nvars, cliquepartition, ncliques) ccall((:SCIPcalcNegatedCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, cliquepartition, ncliques) end @@ -434,11 +434,11 @@ function SCIPgetCliques(scip) ccall((:SCIPgetCliques, libscip), Ptr{Ptr{SCIP_CLIQUE}}, (Ptr{SCIP},), scip) end -function SCIPhaveVarsCommonClique(scip, var1, value1::UInt32, var2, value2::UInt32, regardimplics::UInt32) +function SCIPhaveVarsCommonClique(scip, var1, value1, var2, value2, regardimplics) ccall((:SCIPhaveVarsCommonClique, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, UInt32, UInt32), scip, var1, value1, var2, value2, regardimplics) end -function SCIPwriteCliqueGraph(scip, fname, writenodeweights::UInt32) +function SCIPwriteCliqueGraph(scip, fname, writenodeweights) ccall((:SCIPwriteCliqueGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32), scip, fname, writenodeweights) end @@ -446,47 +446,47 @@ function SCIPremoveVarFromGlobalStructures(scip, var) ccall((:SCIPremoveVarFromGlobalStructures, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPchgVarBranchFactor(scip, var, branchfactor::Cdouble) +function SCIPchgVarBranchFactor(scip, var, branchfactor) ccall((:SCIPchgVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, branchfactor) end -function SCIPscaleVarBranchFactor(scip, var, scale::Cdouble) +function SCIPscaleVarBranchFactor(scip, var, scale) ccall((:SCIPscaleVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, scale) end -function SCIPaddVarBranchFactor(scip, var, addfactor::Cdouble) +function SCIPaddVarBranchFactor(scip, var, addfactor) ccall((:SCIPaddVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addfactor) end -function SCIPchgVarBranchPriority(scip, var, branchpriority::Cint) +function SCIPchgVarBranchPriority(scip, var, branchpriority) ccall((:SCIPchgVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) end -function SCIPupdateVarBranchPriority(scip, var, branchpriority::Cint) +function SCIPupdateVarBranchPriority(scip, var, branchpriority) ccall((:SCIPupdateVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) end -function SCIPaddVarBranchPriority(scip, var, addpriority::Cint) +function SCIPaddVarBranchPriority(scip, var, addpriority) ccall((:SCIPaddVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, addpriority) end -function SCIPchgVarBranchDirection(scip, var, branchdirection::SCIP_BRANCHDIR) +function SCIPchgVarBranchDirection(scip, var, branchdirection) ccall((:SCIPchgVarBranchDirection, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, branchdirection) end -function SCIPchgVarType(scip, var, vartype::SCIP_VARTYPE, infeasible) +function SCIPchgVarType(scip, var, vartype, infeasible) ccall((:SCIPchgVarType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_VARTYPE, Ptr{UInt32}), scip, var, vartype, infeasible) end -function SCIPfixVar(scip, var, fixedval::Cdouble, infeasible, fixed) +function SCIPfixVar(scip, var, fixedval, infeasible, fixed) ccall((:SCIPfixVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infeasible, fixed) end -function SCIPaggregateVars(scip, varx, vary, scalarx::Cdouble, scalary::Cdouble, rhs::Cdouble, infeasible, redundant, aggregated) +function SCIPaggregateVars(scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) ccall((:SCIPaggregateVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) end -function SCIPmultiaggregateVar(scip, var, naggvars::Cint, aggvars, scalars, constant::Cdouble, infeasible, aggregated) +function SCIPmultiaggregateVar(scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) ccall((:SCIPmultiaggregateVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Ptr{UInt32}, Ptr{UInt32}), scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) end @@ -522,67 +522,67 @@ function SCIPdisableVarHistory(scip) ccall((:SCIPdisableVarHistory, libscip), Cvoid, (Ptr{SCIP},), scip) end -function SCIPupdateVarPseudocost(scip, var, solvaldelta::Cdouble, objdelta::Cdouble, weight::Cdouble) +function SCIPupdateVarPseudocost(scip, var, solvaldelta, objdelta, weight) ccall((:SCIPupdateVarPseudocost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, var, solvaldelta, objdelta, weight) end -function SCIPgetVarPseudocostVal(scip, var, solvaldelta::Cdouble) +function SCIPgetVarPseudocostVal(scip, var, solvaldelta) ccall((:SCIPgetVarPseudocostVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) end -function SCIPgetVarPseudocostValCurrentRun(scip, var, solvaldelta::Cdouble) +function SCIPgetVarPseudocostValCurrentRun(scip, var, solvaldelta) ccall((:SCIPgetVarPseudocostValCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) end -function SCIPgetVarPseudocost(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarPseudocost(scip, var, dir) ccall((:SCIPgetVarPseudocost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarPseudocostCurrentRun(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarPseudocostCurrentRun(scip, var, dir) ccall((:SCIPgetVarPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarPseudocostCount(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarPseudocostCount(scip, var, dir) ccall((:SCIPgetVarPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarPseudocostCountCurrentRun(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarPseudocostCountCurrentRun(scip, var, dir) ccall((:SCIPgetVarPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarPseudocostVariance(scip, var, dir::SCIP_BRANCHDIR, onlycurrentrun::UInt32) +function SCIPgetVarPseudocostVariance(scip, var, dir, onlycurrentrun) ccall((:SCIPgetVarPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, UInt32), scip, var, dir, onlycurrentrun) end -function SCIPcalculatePscostConfidenceBound(scip, var, dir::SCIP_BRANCHDIR, onlycurrentrun::UInt32, clevel::SCIP_CONFIDENCELEVEL) +function SCIPcalculatePscostConfidenceBound(scip, var, dir, onlycurrentrun, clevel) ccall((:SCIPcalculatePscostConfidenceBound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, UInt32, SCIP_CONFIDENCELEVEL), scip, var, dir, onlycurrentrun, clevel) end -function SCIPsignificantVarPscostDifference(scip, varx, fracx::Cdouble, vary, fracy::Cdouble, dir::SCIP_BRANCHDIR, clevel::SCIP_CONFIDENCELEVEL, onesided::UInt32) +function SCIPsignificantVarPscostDifference(scip, varx, fracx, vary, fracy, dir, clevel, onesided) ccall((:SCIPsignificantVarPscostDifference, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_VAR}, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL, UInt32), scip, varx, fracx, vary, fracy, dir, clevel, onesided) end -function SCIPpscostThresholdProbabilityTest(scip, var, frac::Cdouble, threshold::Cdouble, dir::SCIP_BRANCHDIR, clevel::SCIP_CONFIDENCELEVEL) +function SCIPpscostThresholdProbabilityTest(scip, var, frac, threshold, dir, clevel) ccall((:SCIPpscostThresholdProbabilityTest, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL), scip, var, frac, threshold, dir, clevel) end -function SCIPisVarPscostRelerrorReliable(scip, var, threshold::Cdouble, clevel::SCIP_CONFIDENCELEVEL) +function SCIPisVarPscostRelerrorReliable(scip, var, threshold, clevel) ccall((:SCIPisVarPscostRelerrorReliable, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, SCIP_CONFIDENCELEVEL), scip, var, threshold, clevel) end -function SCIPgetVarPseudocostScore(scip, var, solval::Cdouble) +function SCIPgetVarPseudocostScore(scip, var, solval) ccall((:SCIPgetVarPseudocostScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) end -function SCIPgetVarPseudocostScoreCurrentRun(scip, var, solval::Cdouble) +function SCIPgetVarPseudocostScoreCurrentRun(scip, var, solval) ccall((:SCIPgetVarPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) end -function SCIPgetVarVSIDS(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarVSIDS(scip, var, dir) ccall((:SCIPgetVarVSIDS, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarVSIDSCurrentRun(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarVSIDSCurrentRun(scip, var, dir) ccall((:SCIPgetVarVSIDSCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end @@ -602,19 +602,19 @@ function SCIPgetVarConflictlengthScoreCurrentRun(scip, var) ccall((:SCIPgetVarConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPgetVarAvgConflictlength(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarAvgConflictlength(scip, var, dir) ccall((:SCIPgetVarAvgConflictlength, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarAvgConflictlengthCurrentRun(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarAvgConflictlengthCurrentRun(scip, var, dir) ccall((:SCIPgetVarAvgConflictlengthCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarAvgInferences(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarAvgInferences(scip, var, dir) ccall((:SCIPgetVarAvgInferences, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarAvgInferencesCurrentRun(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarAvgInferencesCurrentRun(scip, var, dir) ccall((:SCIPgetVarAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end @@ -626,19 +626,19 @@ function SCIPgetVarAvgInferenceScoreCurrentRun(scip, var) ccall((:SCIPgetVarAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPinitVarBranchStats(scip, var, downpscost::Cdouble, uppscost::Cdouble, downvsids::Cdouble, upvsids::Cdouble, downconflen::Cdouble, upconflen::Cdouble, downinfer::Cdouble, upinfer::Cdouble, downcutoff::Cdouble, upcutoff::Cdouble) +function SCIPinitVarBranchStats(scip, var, downpscost, uppscost, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) ccall((:SCIPinitVarBranchStats, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, var, downpscost, uppscost, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) end -function SCIPinitVarValueBranchStats(scip, var, value::Cdouble, downvsids::Cdouble, upvsids::Cdouble, downconflen::Cdouble, upconflen::Cdouble, downinfer::Cdouble, upinfer::Cdouble, downcutoff::Cdouble, upcutoff::Cdouble) +function SCIPinitVarValueBranchStats(scip, var, value, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) ccall((:SCIPinitVarValueBranchStats, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, var, value, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) end -function SCIPgetVarAvgCutoffs(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarAvgCutoffs(scip, var, dir) ccall((:SCIPgetVarAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end -function SCIPgetVarAvgCutoffsCurrentRun(scip, var, dir::SCIP_BRANCHDIR) +function SCIPgetVarAvgCutoffsCurrentRun(scip, var, dir) ccall((:SCIPgetVarAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end @@ -650,11 +650,11 @@ function SCIPgetVarAvgCutoffScoreCurrentRun(scip, var) ccall((:SCIPgetVarAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPgetVarAvgInferenceCutoffScore(scip, var, cutoffweight::Cdouble) +function SCIPgetVarAvgInferenceCutoffScore(scip, var, cutoffweight) ccall((:SCIPgetVarAvgInferenceCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) end -function SCIPgetVarAvgInferenceCutoffScoreCurrentRun(scip, var, cutoffweight::Cdouble) +function SCIPgetVarAvgInferenceCutoffScoreCurrentRun(scip, var, cutoffweight) ccall((:SCIPgetVarAvgInferenceCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) end From baa31dd619016c6411919f4246d6f160313d8761 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 21:40:12 +0100 Subject: [PATCH 11/82] reset README --- README.md | 66 ++++++++----------------------------------------------- 1 file changed, 9 insertions(+), 57 deletions(-) diff --git a/README.md b/README.md index d99daec3..bf62b12a 100644 --- a/README.md +++ b/README.md @@ -5,60 +5,12 @@ Julia interface to [SCIP](http://scip.zib.de) solver. [![Coverage Status](https://coveralls.io/repos/github/SCIP-Interfaces/SCIP.jl/badge.svg?branch=master)](https://coveralls.io/github/SCIP-Interfaces/SCIP.jl?branch=master) [![codecov](https://codecov.io/gh/SCIP-Interfaces/SCIP.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/SCIP-Interfaces/SCIP.jl) -## Related Projects - -- [SCIP](http://scip.zib.de): actual solver (implemented in C) that is wrapped - for Julia. -- [CSIP](https://github.com/SCIP-Interfaces/CSIP): restricted and simplified C - interface to SCIP which our wrapper is based on. -- [SCIP.jl](https://github.com/ryanjoneil/SCIP.jl): previous attempt to - interface SCIP from Julia, using autogenerated wrapper code for all public - functions. -- [MathProgBase](https://github.com/JuliaOpt/MathProgBase.jl): We aim to - implement MPB's abstract solver interfaces, so that one can use SCIP.jl - through [JuMP](https://github.com/JuliaOpt/JuMP.jl). For now, the - `LinearQuadraticModel` interface is implemented, supporting lazy constraint - and heuristic callbacks. - -## Installation - -**Note**: These instructions are meant for and only tested with GNU/Linux. OS X used to work, -but there is an issue (#46) since the update to SCIP 4.0.0. - -Follow the steps below to get SCIP.jl working. Unfortunately, these steps can not be automated as part of `Pkg.build("SCIP")`, because the academic license of SCIP does not allow distribution of the source code without tracking the download metadata. See the [license](http://scip.zib.de/academic.txt) for details. - -1.The SCIP.jl package requires [SCIP](http://scip.zib.de/) to be installed in a recent version (e.g. 6.0.0). -[Download](http://scip.zib.de) the SCIP Optimization Suite. -``` -tar xzf scipoptsuite-6.0.0.tgz -``` - -2.Choose an installation path and set the **environment variable `SCIPOPTDIR`** to point there. -``` -export SCIPOPTDIR=`my/install/dir` -``` - -3.Build and install the shared library with -``` -mkdir build -cd build -cmake -DCMAKE_INSTALL_PREFIX=$SCIPOPTDIR .. -make -make install -``` - -4.This package is registered in `METADATA.jl` and can be installed in Julia with -``` -Pkg.add("SCIP") -``` - -## Setting Parameters - -SCIP has a [long list of parameters](http://scip.zib.de/doc/html/PARAMETERS.php) -that can all be set through SCIP.jl, by passing them to the constructor of -`SCIPSolver`. To set a value `val` to a parameter `name`, pass the two -parameters `(name, val)`. For example, let's set two parameters, to disable -output and increase the gap limit to 0.05: -``` -solver = SCIPSolver("display/verblevel", 0, "limits/gap", 0.05) -``` +This is a complete rewrite. We use +[Clang.jl](https://github.com/ihnorton/Clang.jl) to generate wrappers based on +the headers of the SCIP library. We aim to support +[JuMP](https://github.com/JuliaOpt/JuMP.jl) through +[MathOptInterface](https://github.com/JuliaOpt/MathOptInterface.jl). In this +first pass, only the +[LinQuadOptInterface](https://github.com/JuliaOpt/LinQuadOptInterface.jl) will +be implemented. This means that we will have a feature loss in the areas of +general nonlinear constraints as well as supported callbacks. From 8e1ee3e3b135147874064852f715392ab402bf5b Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 21:40:26 +0100 Subject: [PATCH 12/82] update LICENSE, REQUIRE --- LICENSE | 2 +- REQUIRE | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/LICENSE b/LICENSE index 739a4a47..715709d3 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2016 Robert Schwarz +Copyright (c) 2018 Felipe Serrano, Miles Lubin, Robert Schwarz Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/REQUIRE b/REQUIRE index 1e9d1742..7434265f 100644 --- a/REQUIRE +++ b/REQUIRE @@ -1,3 +1,2 @@ -julia 0.7 +julia 1.0 BinDeps -MathProgBase 0.5 0.8 From 3fd6395f26b7fee24acd281fc6b5e53a7a8130be Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 21:46:30 +0100 Subject: [PATCH 13/82] delete most of the old code (and tests) --- .gitignore | 5 - .travis.yml | 23 -- REQUIRE | 1 - benchmark/sparse_linprog.jl | 42 --- deps/build.jl | 53 ---- deps/csip_version.jl | 9 - src/SCIP.jl | 36 --- src/csip_wrapper.jl | 263 ---------------- src/mpb_interface.jl | 579 ----------------------------------- src/params.jl | 48 --- src/scip_wrapper.jl | 9 - src/types.jl | 73 ----- test/REQUIRE | 2 +- test/csip_tests.jl | 399 ------------------------ test/more_tests.jl | 108 ------- test/mpb_tests.jl | 27 -- test/runtests.jl | 15 - travis_docker_env.list | 10 - travis_docker_test_script.sh | 25 -- 19 files changed, 1 insertion(+), 1726 deletions(-) delete mode 100644 .travis.yml delete mode 100644 benchmark/sparse_linprog.jl delete mode 100644 deps/csip_version.jl delete mode 100644 src/csip_wrapper.jl delete mode 100644 src/mpb_interface.jl delete mode 100644 src/params.jl delete mode 100644 src/scip_wrapper.jl delete mode 100644 src/types.jl delete mode 100644 test/csip_tests.jl delete mode 100644 test/more_tests.jl delete mode 100644 test/mpb_tests.jl delete mode 100644 travis_docker_env.list delete mode 100755 travis_docker_test_script.sh diff --git a/.gitignore b/.gitignore index d1f8fd97..d1da0f2c 100644 --- a/.gitignore +++ b/.gitignore @@ -3,9 +3,4 @@ *.jl.*.cov *.jl.mem deps/deps.jl -deps/downloads/ -deps/src/ -deps/usr/ deps/build.log -/test/test.lp -/test/test.mps diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index fa18edce..00000000 --- a/.travis.yml +++ /dev/null @@ -1,23 +0,0 @@ -# Documentation: http://docs.travis-ci.com/user/languages/julia/ -language: julia -os: - - linux -julia: - - 0.7 - - 1.0 -dist: trusty -sudo: required -services: - - docker -before_install: - - echo "**** pulling Docker image" - - docker pull leethargo/scip-julia -notifications: - email: false -script: - - echo "**** running Docker" - - docker run --env-file travis_docker_env.list -t -a STDOUT -a STDIN -a STDERR -v $PWD:/mnt leethargo/scip-julia /mnt/travis_docker_test_script.sh $TRAVIS_JULIA_VERSION -after_success: - # push coverage results to Coveralls, .cov files were copied back by script above - - echo "**** submitting coverage information" - - julia -e 'using Pkg; Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder()); Codecov.submit(Codecov.process_folder())' diff --git a/REQUIRE b/REQUIRE index 7434265f..05b5ab4c 100644 --- a/REQUIRE +++ b/REQUIRE @@ -1,2 +1 @@ julia 1.0 -BinDeps diff --git a/benchmark/sparse_linprog.jl b/benchmark/sparse_linprog.jl deleted file mode 100644 index ef2431f9..00000000 --- a/benchmark/sparse_linprog.jl +++ /dev/null @@ -1,42 +0,0 @@ -using JuMP -using SCIP - -function create_model(n::Int) - m = Model(solver=SCIPSolver()) - @variable(m, x[1:n] >= 0) - for i=1:n - @constraint(m, 2x[i] - x[n+1-i] >= i) - end - @objective(m, :Min, sum(x[i] for i=1:n)) - JuMP.build(m) -end - -# do it once to precompile -create_model(2) - -for n in [10,100,1000,2000] - println(n) - @time create_model(n) -end - -# benchmark run by rschwarz on 2016/12/09, before 0f426f1: -# $ julia sparse_linprog.jl -# 10 -# 0.002850 seconds (328 allocations: 23.344 KB) -# 100 -# 0.003571 seconds (1.70 k allocations: 203.953 KB) -# 1000 -# 0.055860 seconds (16.20 k allocations: 8.760 MB) -# 2000 -# 0.222766 seconds (33.21 k allocations: 32.780 MB, 4.31% gc time) - -# after 0f426f1: -# $ julia sparse_linprog.jl -# 10 -# 0.002882 seconds (353 allocations: 25.938 KB) -# 100 -# 0.002924 seconds (1.90 k allocations: 155.313 KB) -# 1000 -# 0.004558 seconds (18.21 k allocations: 1.383 MB) -# 2000 -# 0.006455 seconds (37.22 k allocations: 2.766 MB) diff --git a/deps/build.jl b/deps/build.jl index 39da09d1..5ee96c53 100644 --- a/deps/build.jl +++ b/deps/build.jl @@ -1,54 +1 @@ -using BinDeps - using Libdl - -include("csip_version.jl") - -CSIP_URL = "https://github.com/SCIP-Interfaces/CSIP/archive/v$(CSIP_VERSION).zip" -CSIP_LIB = "libcsip" -CSIP_UNPACKED = "CSIP-$(CSIP_VERSION)" - -@BinDeps.setup - -@assert haskey(ENV, "SCIPOPTDIR") "Environment variable `SCIPOPTDIR` not set!" - -function validate_csip(name, handle) - csip_version = ccall(Libdl.dlsym(handle, :CSIPgetVersion), Cint, ()) - csip_version == csip_required_int -end - -csipdep = library_dependency(CSIP_LIB, validate=validate_csip) - -provides(Sources, Dict(URI(CSIP_URL) => csipdep), - unpacked_dir=CSIP_UNPACKED) - -src_dir = joinpath(BinDeps.srcdir(csipdep), CSIP_UNPACKED) -scipopt_dir = ENV["SCIPOPTDIR"] - -provides(SimpleBuild, - (@build_steps begin - GetSources(csipdep) - @build_steps begin - ChangeDirectory(joinpath(BinDeps.srcdir(csipdep), CSIP_UNPACKED)) - `make` - `gcc -std=c99 -Wall -pedantic -I$(src_dir)/lib/include -I$(src_dir)/include -c $(src_dir)/src/csip.c -L$(src_dir)/lib -Wl,-rpath,$(scipopt_dir)/lib/ $(scipopt_dir)/lib/libscipopt.dylib -fPIC -o $(src_dir)/src/csip.o` - ` gcc -std=c99 -Wall -pedantic $(src_dir)/src/csip.o -L$(src_dir)/lib -Wl,-rpath,$(scipopt_dir)/lib/ $(scipopt_dir)/lib/libscipopt.dylib -fPIC -shared -dynamiclib -o $(src_dir)/lib/libcsip.dylib` - `mkdir -p $(libdir(csipdep))` - `install lib/libcsip.dylib $(libdir(csipdep))` - end - end), csipdep, os = :Darwin) - - -provides(SimpleBuild, - (@build_steps begin - GetSources(csipdep) - @build_steps begin - ChangeDirectory(joinpath(BinDeps.srcdir(csipdep), CSIP_UNPACKED)) - `make` - `mkdir -p $(libdir(csipdep))` - `install lib/libcsip.so $(libdir(csipdep))` - end - end), csipdep, os = :Unix) - - -@BinDeps.install Dict(:libcsip => :libcsip) diff --git a/deps/csip_version.jl b/deps/csip_version.jl deleted file mode 100644 index 25a21372..00000000 --- a/deps/csip_version.jl +++ /dev/null @@ -1,9 +0,0 @@ -# required version and utilities in a single location -CSIP_VERSION = "0.6.0" - -function vn2int(vn::VersionNumber) - 100*vn.major + 10*vn.minor + vn.patch -end - -csip_required = VersionNumber(CSIP_VERSION) -csip_required_int = vn2int(csip_required) diff --git a/src/SCIP.jl b/src/SCIP.jl index ed132896..ebd58aa4 100644 --- a/src/SCIP.jl +++ b/src/SCIP.jl @@ -1,39 +1,3 @@ module SCIP -if isfile(joinpath(dirname(@__FILE__),"..","deps","deps.jl")) - include("../deps/deps.jl") -else - error("SCIP.jl not properly installed. Please run Pkg.build(\"SCIP\")") -end - -include("../deps/csip_version.jl") - -using SparseArrays: issparse, findnz - -import MathProgBase -import MathProgBase.SolverInterface: AbstractLinearQuadraticModel, - AbstractNonlinearModel, - AbstractMathProgSolver, - MathProgCallbackData, - AbstractNLPEvaluator, - LinearQuadraticModel - -include("types.jl") -include("csip_wrapper.jl") -include("scip_wrapper.jl") -include("mpb_interface.jl") -include("params.jl") - -function CSIPversion() - VersionNumber("$(_majorVersion()).$(_minorVersion()).$(_patchVersion())") -end - -function __init__() - csip_installed = CSIPversion() - if csip_installed != csip_required - depsdir = realpath(joinpath(dirname(@__FILE__),"..","deps")) - error("Installed CSIP version is $(csip_installed), but we require $(csip_required). Run Pkg.build(\"SCIP\") to update.") - end -end - end diff --git a/src/csip_wrapper.jl b/src/csip_wrapper.jl deleted file mode 100644 index c0348035..00000000 --- a/src/csip_wrapper.jl +++ /dev/null @@ -1,263 +0,0 @@ -# calls to CSIP library, wrapping SCIP - -function _majorVersion() - ccall((:CSIPmajorVersion, libcsip), Cint, ()) -end - -function _minorVersion() - ccall((:CSIPminorVersion, libcsip), Cint, ()) -end - -function _patchVersion() - ccall((:CSIPpatchVersion, libcsip), Cint, ()) -end - -function _freeModel(inner::SCIPModel) - ccall((:CSIPfreeModel, libcsip), Cint, (Ptr{Cvoid}, ), inner.ptr_model) -end - -function _addVar(model::SCIPMathProgModel, lowerbound::Cdouble, - upperbound::Cdouble, vartype::Cint, idx::Ptr{Cint}) - ccall((:CSIPaddVar, libcsip), Cint, - (Ptr{Cvoid}, Cdouble, Cdouble, Cint, Ptr{Cint}), - model.inner.ptr_model, lowerbound, upperbound, vartype, idx) -end - -function _chgVarLB(model::SCIPMathProgModel, numindices::Cint, - indices::Vector{Cint}, lowerbounds::Vector{Cdouble}) - ccall((:CSIPchgVarLB, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}), - model.inner.ptr_model, numindices, indices, lowerbounds) -end - -function _chgVarUB(model::SCIPMathProgModel, numindices::Cint, - indices::Vector{Cint}, upperbounds::Vector{Cdouble}) - ccall((:CSIPchgVarUB, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}), - model.inner.ptr_model, numindices, indices, upperbounds) -end - -function _getVarType(model::SCIPMathProgModel, varindex::Cint) - ccall((:CSIPgetVarType, libcsip), Cint, - (Ptr{Cvoid}, Cint), - model.inner.ptr_model, varindex) -end - -function _chgVarType(model::SCIPMathProgModel, varindex::Cint, vartype::Cint) - ccall((:CSIPchgVarType, libcsip), Cint, - (Ptr{Cvoid}, Cint, Cint), - model.inner.ptr_model, varindex, vartype) -end - -function _addLinCons(model::SCIPMathProgModel, numindices::Cint, - indices::Vector{Cint}, coefs::Vector{Cdouble}, - lhs::Cdouble, rhs::Cdouble, idx::Ptr{Cint}) - ccall((:CSIPaddLinCons, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cdouble, Ptr{Cint}), - model.inner.ptr_model, numindices, indices, coefs, lhs, rhs, idx) -end - -function _addQuadCons(model::SCIPMathProgModel, numlinindices::Cint, - linindices::Vector{Cint}, lincoefs::Vector{Cdouble}, - numquadterms::Cint, quadrowindices::Vector{Cint}, - quadcolindices::Vector{Cint}, quadcoefs::Vector{Cdouble}, - lhs::Cdouble, rhs::Cdouble, idx::Ptr{Cint}) - ccall((:CSIPaddQuadCons, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}, Ptr{Cint}, - Ptr{Cdouble}, Cdouble, Cdouble, Ptr{Cint}), - model.inner.ptr_model, numlinindices, linindices, lincoefs, numquadterms, - quadrowindices, quadcolindices, quadcoefs, lhs, rhs, idx) -end - -function _addNonLinCons(model::SCIPMathProgModel, nops::Cint, - ops::Vector{Cint}, children::Vector{Cint}, - beg::Vector{Cint}, values::Vector{Cdouble}, - lhs::Cdouble, rhs::Cdouble, idx::Ptr{Cint}) - ccall((:CSIPaddNonLinCons, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cdouble, Ptr{Cint}), - model.inner.ptr_model, nops, ops, children, beg, values, lhs, rhs, idx) -end - -function _addSOS1(model::SCIPMathProgModel, numindices::Cint, - indices::Vector{Cint}, weights::Vector{Cdouble}, - idx::Ptr{Cint}) - ccall((:CSIPaddSOS1, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}), - model.inner.ptr_model, numindices, indices, weights, idx) -end - -function _addSOS2(model::SCIPMathProgModel, numindices::Cint, - indices::Vector{Cint}, weights::Vector{Cdouble}, - idx::Ptr{Cint}) - ccall((:CSIPaddSOS2, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}), - model.inner.ptr_model, numindices, indices, weights, idx) -end - -function _setObj(model::SCIPMathProgModel, numindices::Cint, - indices::Vector{Cint}, coefs::Vector{Cdouble}) - ccall((:CSIPsetObj, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}), - model.inner.ptr_model, numindices, indices, coefs) -end - -function _setQuadObj(model::SCIPMathProgModel, numlinindices::Cint, - linindices::Vector{Cint}, lincoefs::Vector{Cdouble}, - numquadterms::Cint, quadrowindices::Vector{Cint}, - quadcolindices::Vector{Cint}, quadcoefs::Vector{Cdouble}) - ccall((:CSIPsetQuadObj, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}, Ptr{Cint}, - Ptr{Cdouble}), - model.inner.ptr_model, numlinindices, linindices, lincoefs, numquadterms, - quadrowindices, quadcolindices, quadcoefs) -end - -function _setNonlinearObj(model::SCIPMathProgModel, nops::Cint, - ops::Vector{Cint}, children::Vector{Cint}, - beg::Vector{Cint}, values::Vector{Cdouble}) - ccall((:CSIPsetNonlinearObj, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), - model.inner.ptr_model, nops, ops, children, beg, values) -end - -function _setSenseMinimize(model::SCIPMathProgModel) - ccall((:CSIPsetSenseMinimize, libcsip), Cint, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _setSenseMaximize(model::SCIPMathProgModel) - ccall((:CSIPsetSenseMaximize, libcsip), Cint, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _solve(model::SCIPMathProgModel) - ccall((:CSIPsolve, libcsip), Cint, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _interrupt(model::SCIPMathProgModel) - ccall((:CSIPinterrupt, libcsip), Cint, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _getVarValues(model::SCIPMathProgModel, output::Vector{Cdouble}) - ccall((:CSIPgetVarValues, libcsip), Cint, (Ptr{Cvoid}, Ptr{Cdouble}), - model.inner.ptr_model, output) -end - -function _getObjValue(model::SCIPMathProgModel) - ccall((:CSIPgetObjValue, libcsip), Cdouble, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _getObjBound(model::SCIPMathProgModel) - ccall((:CSIPgetObjBound, libcsip), Cdouble, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _getStatus(model::SCIPMathProgModel) - ccall((:CSIPgetStatus, libcsip), Cint, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _getParamType(model::SCIPMathProgModel, name::Ptr{UInt8}) - ccall((:CSIPgetParamType, libcsip), Cint, - (Ptr{Cvoid}, Ptr{UInt8}), - model.inner.ptr_model, name) -end - -function _setBoolParam(model::SCIPMathProgModel, name::Ptr{UInt8}, - value::Cint) - ccall((:CSIPsetBoolParam, libcsip), Cint, - (Ptr{Cvoid}, Ptr{UInt8}, Cint), - model.inner.ptr_model, name, value) -end - -function _setIntParam(model::SCIPMathProgModel, name::Ptr{UInt8}, - value::Cint) - ccall((:CSIPsetIntParam, libcsip), Cint, - (Ptr{Cvoid}, Ptr{UInt8}, Cint), - model.inner.ptr_model, name, value) -end - -function _setLongintParam(model::SCIPMathProgModel, name::Ptr{UInt8}, - value::Clonglong) - ccall((:CSIPsetLongintParam, libcsip), Cint, - (Ptr{Cvoid}, Ptr{UInt8}, Clonglong), - model.inner.ptr_model, name, value) -end - -function _setRealParam(model::SCIPMathProgModel, name::Ptr{UInt8}, - value::Cdouble) - ccall((:CSIPsetRealParam, libcsip), Cint, - (Ptr{Cvoid}, Ptr{UInt8}, Cdouble), - model.inner.ptr_model, name, value) -end - -function _setCharParam(model::SCIPMathProgModel, name::Ptr{UInt8}, - value::Cchar) - ccall((:CSIPsetCharParam, libcsip), Cint, - (Ptr{Cvoid}, Ptr{UInt8}, Cchar), - model.inner.ptr_model, name, value) -end - -function _setStringParam(model::SCIPMathProgModel, name::Ptr{UInt8}, - value::Ptr{UInt8}) - ccall((:CSIPsetStringParam, libcsip), Cint, - (Ptr{Cvoid}, Ptr{UInt8}, Ptr{UInt8}), - model.inner.ptr_model, name, value) -end - -function _getNumVars(model::SCIPMathProgModel) - ccall((:CSIPgetNumVars, libcsip), Cint, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _getNumConss(model::SCIPMathProgModel) - ccall((:CSIPgetNumConss, libcsip), Cint, (Ptr{Cvoid}, ), model.inner.ptr_model) -end - -function _setInitialSolution(model::SCIPMathProgModel, values::Vector{Cdouble}) - ccall((:CSIPsetInitialSolution, libcsip), Cint, (Ptr{Cvoid}, Ptr{Cdouble}), - model.inner.ptr_model, values) -end - -function _lazyGetContext(lazydata::Ptr{Cvoid}) - ccall((:CSIPlazyGetContext, libcsip), Cint, (Ptr{Cvoid}, ), lazydata) -end - -function _lazyGetVarValues(lazydata::Ptr{Cvoid}, output::Vector{Cdouble}) - ccall((:CSIPlazyGetVarValues, libcsip), Cint, (Ptr{Cvoid}, Ptr{Cdouble}), - lazydata, output) -end - -function _lazyAddLinCons(lazydata::Ptr{Cvoid}, numindices::Cint, - indices::Vector{Cint}, coefs::Vector{Cdouble}, - lhs::Cdouble, rhs::Cdouble, islocal::Cint) - ccall((:CSIPlazyAddLinCons, libcsip), Cint, - (Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cdouble, Cint), - lazydata, numindices, indices, coefs, lhs, rhs, islocal) -end - -function _addLazyCallback(model::SCIPMathProgModel, lazycb::Ptr{Cvoid}, userdata) - ccall((:CSIPaddLazyCallback, libcsip), Cint, - (Ptr{Cvoid}, Ptr{Cvoid}, Any), - model.inner.ptr_model, lazycb, userdata) -end - -function _heurGetVarValues(heurdata::Ptr{Cvoid}, output::Vector{Cdouble}) - ccall((:CSIPheurGetVarValues, libcsip), Cint, (Ptr{Cvoid}, Ptr{Cdouble}), - heurdata, output) -end - -function _heurAddSolution(heurdata::Ptr{Cvoid}, values::Vector{Cdouble}) - ccall((:CSIPheurAddSolution, libcsip), Cint, (Ptr{Cvoid}, Ptr{Cdouble}), - heurdata, values) -end - -function _addHeuristicCallback(model::SCIPMathProgModel, heur::Ptr{Cvoid}, userdata) - ccall((:CSIPaddHeuristicCallback, libcsip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}, Any), - model.inner.ptr_model, heur, userdata) -end - -function _getInternalSCIP(model::SCIPMathProgModel) - ccall((:CSIPgetInternalSCIP, libcsip), Ptr{Cvoid}, (Ptr{Cvoid}, ), - model.inner.ptr_model) -end - -function _setMessagePrefix(model::SCIPMathProgModel, prefix::Ptr{UInt8}) - ccall((:CSIPsetMessagePrefix, libcsip), Cint, (Ptr{Cvoid}, Cstring), - model.inner.ptr_model, prefix) -end diff --git a/src/mpb_interface.jl b/src/mpb_interface.jl deleted file mode 100644 index 45846f4e..00000000 --- a/src/mpb_interface.jl +++ /dev/null @@ -1,579 +0,0 @@ -# Interface - -########################################################################################################### -##### Methods common to all: AbstractLinearQuadraticModel, AbstractConicModel, AbstractNonlinearModel ##### -##### see: http://mathprogbasejl.readthedocs.io/en/latest/solverinterface.html ##### -########################################################################################################### - -MathProgBase.getobjgap(m::SCIPMathProgModel) = error("Not implemented for SCIP.jl!") - -MathProgBase.getrawsolver(m::SCIPMathProgModel) = error("Not implemented for SCIP.jl!") - -MathProgBase.getsolvetime(m::SCIPMathProgModel) = ccall((:SCIPgetSolvingTime, libcsip), Cdouble, (Ptr{Cvoid},), _getInternalSCIP(m)) - -MathProgBase.getsense(m::SCIPMathProgModel) = error("Not implemented for SCIP.jl!") - -MathProgBase.numvar(m::SCIPMathProgModel) = _getNumVars(m) - -"The number of proper constraints, excluding those from lazy callbacks." -MathProgBase.numconstr(m::SCIPMathProgModel) = _getNumConss(m) - -function MathProgBase.freemodel!(m::SCIPMathProgModel) - if m.inner.ptr_model != C_NULL - # call finalizer directly - freescip(m.inner) - else - @warn("Tried to free already freed model, ignoring.") - end -end - -# TODO: mapping for :SemiCont, :SemiInt -const vartypemap = Dict{Symbol, Cint}( - :Cont => 3, - :Bin => 0, - :Int => 1 -) -const revvartypemap = Dict{Cint, Symbol}( - 3 => :Cont, - 0 => :Bin, - 1 => :Int -) - -function MathProgBase.getvartype(m::SCIPMathProgModel) - nvars = _getNumVars(m) - types = zeros(nvars) - for idx = one(Cint):nvars - types[idx] = _getVarType(m, idx - one(Cint)) - end - return map(x -> revvartypemap[x], types) -end - -function MathProgBase.setvartype!(m::SCIPMathProgModel, vartype::Vector{Symbol}) - nvars = Cint(length(vartype)) - scipvartypes = map(vt -> vartypemap[vt], vartype) - for idx = one(Cint):nvars - _chgVarType(m, idx - one(Cint), scipvartypes[idx]) - end -end - -MathProgBase.optimize!(m::SCIPMathProgModel) = _solve(m) - -function MathProgBase.status(m::SCIPMathProgModel) - statusmap = [:Optimal, - :Infeasible, - :Unbounded, - :InfeasibleOrUnbounded, - :UserLimit, # node limit - :UserLimit, # time limit - :UserLimit, # memory limit - :UserLimit, # user limit - :Unknown # TODO: find good value - ] - stat = _getStatus(m) - return statusmap[stat + 1] -end - -MathProgBase.getobjbound(m::SCIPMathProgModel) = _getObjBound(m) - -MathProgBase.getobjval(m::SCIPMathProgModel) = _getObjValue(m) - -function MathProgBase.getsolution(m::SCIPMathProgModel) - nvars = _getNumVars(m) - values = zeros(nvars) - _getVarValues(m, values) - values -end - -function MathProgBase.setsense!(m::SCIPMathProgModel, sense) - if sense == :Max - _setSenseMaximize(m) - else - _setSenseMinimize(m) - end -end - -function MathProgBase.setparameters!(s::SCIPSolver; mpboptions...) - opts = collect(Any,s.options) - for (optname, optval) in mpboptions - if optname == :TimeLimit - push!(opts, "limits/time") - push!(opts, optval) - elseif optname == :Silent - if optval == true - push!(opts, "display/verblevel") - push!(opts, 0) - end - else - error("Unrecognized parameter $optname") - end - end - s.options = opts - return -end - -function MathProgBase.setparameters!(m::SCIPMathProgModel; mpboptions...) - for (optname, optval) in mpboptions - if optname == :TimeLimit - setparameter!(m, "limits/time", float(optval)) - elseif optname == :Silent - if optval == true - setparameter!(m, "display/verblevel", 0) - end - else - error("Unrecognized parameter $optname") - end - end -end - -"Set warm-start solution candidate. Missing values are indicated by NaN." -function MathProgBase.setwarmstart!(m::SCIPMathProgModel, v) - _setInitialSolution(m, float(v)) -end - -########################################################################### -##### Methods specific to AbstractLinearQuadraticModel ##### -##### see: http://mathprogbasejl.readthedocs.io/en/latest/lpqcqp.html ##### -########################################################################### - -MathProgBase.loadproblem!(m::SCIPLinearQuadraticModel, filename::AbstractString) = - error("Not implemented for SCIP.jl") - -function MathProgBase.loadproblem!(m::SCIPLinearQuadraticModel, A, varlb, varub, obj, rowlb, rowub, sense) - # TODO: clean old model? - - nrows, ncols = size(A) - nvars = Cint(ncols) - varindices = collect(zero(Cint):nvars - one(Cint)) - - for v in 1:ncols - # TODO: define enum for vartype? - _addVar(m, float(varlb[v]), float(varub[v]), - Cint(3), Ptr{Cint}(C_NULL)) - end - if issparse(A) - At = A' # faster column-wise access in loop - for c in 1:nrows - idx, val = findnz(At[:,c]) - _idx = Vector{Cint}(idx .- 1) # 0 based indexing - _nvars = Cint(length(_idx)) - _addLinCons(m, _nvars, _idx, float(val), - float(rowlb[c]), float(rowub[c]), Ptr{Cint}(C_NULL)) - end - else - for c in 1:nrows - _addLinCons(m, nvars, varindices, float(A[c, :]), - float(rowlb[c]), float(rowub[c]), Ptr{Cint}(C_NULL)) - end - end - - _setObj(m, nvars, varindices, float(obj)) - - if sense == :Max - _setSenseMaximize(m) - else - _setSenseMinimize(m) - end -end - -function MathProgBase.writeproblem(m::SCIPMathProgModel, filename::AbstractString) - _writeOrigProblem(m, Cstring(pointer(filename)), Cstring(C_NULL), Cint(0)) -end - -MathProgBase.getvarLB(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -function MathProgBase.setvarLB!(m::SCIPLinearQuadraticModel, lb) - indices = collect(zero(Cint):Cint(numvar(m) - 1)) - _chgVarLB(m, Cint(numvar(m)), indices, float(lb)) -end - -MathProgBase.getvarUB(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -function MathProgBase.setvarUB!(m::SCIPLinearQuadraticModel, ub) - indices = collect(zero(Cint):Cint(numvar(m) - 1)) - _chgVarUB(m, Cint(numvar(m)), indices, float(ub)) -end - -MathProgBase.getconstrLB(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -# setconstrLB!(m::SCIPLinearQuadraticModel, lb) = error("Not implemented for SCIP.jl") - -MathProgBase.getconstrUB(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -# setconstrUB!(m::SCIPLinearQuadraticModel, ub) = error("Not implemented for SCIP.jl") - -MathProgBase.getobj(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -function MathProgBase.setobj!(m::SCIPLinearQuadraticModel, obj) - indices = collect(zero(Cint):Cint(numvar(m) - 1)) - _setObj(m, Cint(numvar(m)), indices, float(obj)) -end - -MathProgBase.getconstrmatrix(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.addvar!(m::SCIPLinearQuadraticModel, constridx, constrcoef, l, u, objcoef) = - error("Not implemented for SCIP.jl") - -MathProgBase.addvar!(m::SCIPLinearQuadraticModel, l, u, objcoef) = error("Not implemented for SCIP.jl") - -function MathProgBase.addconstr!(m::SCIPLinearQuadraticModel, varidx, coef, lb, ub) - _addLinCons(m, Cint(length(varidx)), Vector{Cint}(varidx .- 1), float(coef), - float(lb), float(ub), Ptr{Cint}(C_NULL)) -end - -MathProgBase.numlinconstr(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getconstrsolution(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getreducedcosts(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getconstrduals(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getinfeasibilityray(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getbasis(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getunboundedray(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getsimplexiter(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getbarrieriter(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -########################################################################## -##### Methods specific to Integer Programming ##### -########################################################################## - -MathProgBase.getnodecount(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -function MathProgBase.addsos1!(m::SCIPLinearQuadraticModel, idx, weight) - nidx = Cint(length(idx)) - cidx = convert(Vector{Cint}, idx .- 1) - _addSOS1(m, nidx, cidx, weight, Ptr{Cint}(C_NULL)) -end - -function MathProgBase.addsos2!(m::SCIPLinearQuadraticModel, idx, weight) - nidx = Cint(length(idx)) - cidx = convert(Vector{Cint}, idx .- 1) - _addSOS2(m, nidx, cidx, weight, Ptr{Cint}(C_NULL)) -end - -########################################################################## -##### Methods specific to Quadratic Programming ##### -########################################################################## - -MathProgBase.numquadconstr(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.setquadobj!(m::SCIPLinearQuadraticModel, Q::Array{T, 2}) where {T<:Real} = - error("Not implemented for SCIP.jl") - -MathProgBase.setquadobj!(m::SCIPLinearQuadraticModel, rowidx, colidx, quadval) = - error("Not implemented for SCIP.jl") - -MathProgBase.setquadobjterms!(m::SCIPLinearQuadraticModel, rowidx, colidx, quadval) = - _setQuadObj(m, Cint(0), Array{Cint}(undef, 0), Array{Cdouble}(undef, 0), - Cint(length(rowidx)), convert(Vector{Cint}, rowidx .- 1), - convert(Vector{Cint}, colidx .- 1), quadval) - -function MathProgBase.addquadconstr!(m::SCIPLinearQuadraticModel, linearidx, linearval, quadrowidx, quadcolidx, quadval, sense, rhs) - clhs = -Inf - crhs = Inf - if sense == '<' - crhs = rhs - elseif sense == '>' - clhs = rhs - else - @assert sense == '=' - clhs = rhs - crhs = rhs - end - _addQuadCons(m, Cint(length(linearidx)), convert(Vector{Cint}, linearidx .- 1), - convert(Vector{Cdouble}, linearval), Cint(length(quadrowidx)), - convert(Vector{Cint}, quadrowidx .- 1), - convert(Vector{Cint}, quadcolidx .- 1), quadval, clhs, crhs, - Ptr{Cint}(C_NULL)) -end - -MathProgBase.getquadconstrsolution(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getquadconstrduals(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getquadinfeasibilityray(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.getquadconstrRHS(m::SCIPLinearQuadraticModel) = error("Not implemented for SCIP.jl") - -MathProgBase.setquadconstrRHS!(m::SCIPLinearQuadraticModel, lb) = error("Not implemented for SCIP.jl") - -########################################################################## -##### Methods specific to MIP Callbacks ##### -########################################################################## - -# use a different type for heuristic callback and multiple dispatch to implements -# the methods that they share -abstract type SCIPCallbackData <: MathProgBase.MathProgCallbackData end - -mutable struct SCIPLazyCallbackData <: SCIPCallbackData - model::SCIPMathProgModel - csip_lazydata::Ptr{Cvoid} -end - -# this is the function that should fit the CSIP_LAZYCALLBACK signature -function lazycb_wrapper(csip_model::Ptr{Cvoid}, csip_lazydata::Ptr{Cvoid}, - userdata::Ptr{Cvoid}) - # m, f = unsafe_pointer_to_objref(userdata)::(SCIPMathProgModel, Function) - # WTF: TypeError: typeassert: expected Type{T}, got Tuple{DataType,DataType} - m, f = unsafe_pointer_to_objref(userdata) - d = SCIPLazyCallbackData(m, csip_lazydata) - ret = f(d) - ret == :Exit && _interrupt(m) - - return convert(Cint, 0) # CSIP_RETCODE_OK -end - -function MathProgBase.setlazycallback!(m::SCIPMathProgModel, f) - # f is function(d::SCIPLazyCallbackData) - - cbfunction = @cfunction(lazycb_wrapper, Cint, - (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid})) - m.inner.lazy_userdata = (m, f) - - _addLazyCallback(m, cbfunction, m.inner.lazy_userdata) -end - -# if we are called from a lazy callback, we check whether the LP relaxation is integral -function MathProgBase.cbgetstate(d::SCIPLazyCallbackData) - context = _lazyGetContext(d.csip_lazydata) - mapping = [:MIPNode, :MIPSol, :Intermediate] - mapping[context + 1] -end - -function MathProgBase.cbgetlpsolution(d::SCIPLazyCallbackData, output) - _lazyGetVarValues(d.csip_lazydata, output) -end - -#TODO: what should we do if there is no best solution? -MathProgBase.cbgetmipsolution(d::SCIPLazyCallbackData, output) = - MathProgBase.cbgetlpsolution(d, output) - -function MathProgBase.cbgetlpsolution(d::SCIPCallbackData) - output = Array(Float64, _getNumVars(m)) - MathProgBase.cbgetlpsolution(d, output) -end - -#TODO: what should we do if there is no best solution? -MathProgBase.cbgetmipsolution(d::SCIPLazyCallbackData) = - MathProgBase.cbgetlpsolution(d) - -function MathProgBase.cbaddlazy!(d::SCIPLazyCallbackData, varidx, varcoef, sense, rhs) - clhs = -Inf - crhs = Inf - if sense == '<' - crhs = rhs - elseif sense == '>' - clhs = rhs - else - @assert sense == '=' - clhs = rhs - crhs = rhs - end - _lazyAddLinCons(d.csip_lazydata, convert(Cint, length(varidx)), - convert(Vector{Cint}, varidx .- 1), varcoef, clhs, crhs, - convert(Cint, 0)) -end - -# function cbaddlazylocal!(d::SCIPLazyCallbackData, varidx, varcoef, sense, rhs) -# end - -mutable struct SCIPHeurCallbackData <: SCIPCallbackData - model::SCIPMathProgModel - csip_heurdata::Ptr{Cvoid} - sol::Vector{Float64} -end - -# this is the function that should fit the CSIP_HEURCALLBACK signature -function heurcb_wrapper(csip_model::Ptr{Cvoid}, csip_heurdata::Ptr{Cvoid}, - userdata::Ptr{Cvoid}) - # m, f = unsafe_pointer_to_objref(userdata)::(SCIPMathProgModel, Function) - # WTF: TypeError: typeassert: expected Type{T}, got Tuple{DataType,DataType} - m, f = unsafe_pointer_to_objref(userdata) - d = SCIPHeurCallbackData(m, csip_heurdata, fill(NaN, MathProgBase.numvar(m))) - - ret = f(d) - ret == :Exit && _interrupt(m) - - return convert(Cint, 0) # CSIP_RETCODE_OK -end - -function MathProgBase.setheuristiccallback!(m::SCIPMathProgModel, f) - # f is function(d::SCIPHeurCallbackData) - - cbfunction = @cfunction(heurcb_wrapper, Cint, - (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid})) - m.inner.heur_userdata = (m, f) - - _addHeuristicCallback(m, cbfunction, m.inner.heur_userdata) -end - -# TODO: detect :MIPSol like with lazy constraints? -MathProgBase.cbgetstate(d::SCIPHeurCallbackData) = :MIPNode - -function MathProgBase.cbgetlpsolution(d::SCIPHeurCallbackData, output) - _heurGetVarValues(d.csip_heurdata, output) -end - -function MathProgBase.cbaddsolution!(d::SCIPHeurCallbackData) - # check for unspecified values (NaN) - if findfirst(isnan, d.sol) == nothing - # add solution that was filled from cbsetsolutionvalue - _heurAddSolution(d.csip_heurdata, d.sol) - else - @warn("Incomplete solutions not supported, skipping candidate.") - end - - # reset solution vector for the next solution - d.sol = fill(NaN, MathProgBase.numvar(d.model)) -end - -function MathProgBase.cbsetsolutionvalue!(d::SCIPHeurCallbackData, varidx, value) - d.sol[varidx] = value -end - -########################################################################## -##### Methods specific to AbstractConicModel ##### -##### see: http://mathprogbasejl.readthedocs.io/en/latest/conic.html ##### -########################################################################## - -######################################################################## -##### Methods specific to AbstractNonlinear ##### -##### see: http://mathprogbasejl.readthedocs.io/en/latest/nlp.html ##### -######################################################################## -const julia_op_to_csip_op = Dict{Symbol, Int}( - :- => 9, - :/ => 11, - :sqrt => 13, - :^ => 14, - :exp => 17, - :log => 18, - :+ => 64, - :* => 65 -) - -#inspired in ReverseDiffSparse's conversion.jl -struct CSIPNodeData - nodetype::Int - childids::Array{Int} -end - -# parse constraint expression into something easier for CSIP -function constr_expr_to_nodedata(ex::Expr) - values = Float64[] - csipex = CSIPNodeData[] - - # a ex.args is [side, comp, expr, comp, side] or [comp, expr, side] - if length(ex.args) == 5 # two sided constraint - expr_to_csip(ex.args[3], values, csipex) - else - @assert length(ex.args) == 3 - expr_to_csip(ex.args[2], values, csipex) - end - return csipex, values -end - -# parse objective expression into something easier for CSIP -function obj_expr_to_nodedata(ex::Expr) - values = Float64[] - csipex = CSIPNodeData[] - expr_to_csip(ex, values, csipex) - return csipex, values -end - -# store expression tree as an array of CSIPNodeData -# Each element of a CSIPNodeData consists of the operator identifier -# and an array with the position of the operator's children. -# For each node in the expression tree, first process its children -# (creating an array with their position) and afterwards add create a new -# node with the node's operator and the position of its children. -function expr_to_csip(ex::Expr, values, csipex) - if Meta.isexpr(ex,:call) # functional operator - # create node - childids = [] - op = ex.args[1] - nchildren = length(ex.args) - for c in 2:nchildren # the first actual children is in positin 2 - pos = expr_to_csip(ex.args[c], values, csipex) - push!(childids, pos) - end - push!(csipex, CSIPNodeData(julia_op_to_csip_op[op], childids)) - - elseif Meta.isexpr(ex, :ref) # variable - @assert ex.args[1] == :x - push!(csipex, CSIPNodeData(1, [ex.args[2]])) - - else # not supported I guess - error("Unrecognized expression $ex: $(ex.head), probably not supported") - end - return length(csipex) -end - -# parsing values -function expr_to_csip(ex::Number, values, csipex) - valueidx = length(values)+1 - push!(values,ex) - push!(csipex, CSIPNodeData(2, [valueidx])) - return length(csipex) -end - - -# the AbstractNLPEvaluator contains the constraints and objective. -# One can get different data from it (with initialize) -# SCIP doesn't need most of the data, just the epression -function MathProgBase.loadproblem!(m::SCIPNonlinearModel, numVars, numConstr, - l, u, lb, ub, sense, d::AbstractNLPEvaluator) - # add variables - for v in Base.OneTo(numVars) - _addVar(m, float(l[v]), float(u[v]), Cint(3), Ptr{Cint}(C_NULL)) - end - - # we want to get the expressions - MathProgBase.initialize(d, [:ExprGraph]) - - # add constraints - for c in Base.OneTo(numConstr) - csipex, values = constr_expr_to_nodedata(MathProgBase.constr_expr(d, c)) - children = Cint[] - beg = Cint[1] - ops = Cint[] - for node in csipex - ops = [ops; node.nodetype] - children = [children; node.childids] - push!(beg, beg[end]+length(node.childids)) - end - _addNonLinCons(m, Cint(length(ops)), - convert(Vector{Cint},ops), - convert(Vector{Cint},children .- 1), - convert(Vector{Cint},beg .- 1), - values, float(lb[c]), float(ub[c]), - Ptr{Cint}(C_NULL)) - end - - # add objective - csipex, values = obj_expr_to_nodedata(MathProgBase.obj_expr(d)) - children = Cint[] - beg = Cint[1] - ops = Cint[] - for node in csipex - ops = [ops; node.nodetype] - children = [children; node.childids] - push!(beg, beg[end]+length(node.childids)) - end - _setNonlinearObj(m, Cint(length(ops)), - convert(Vector{Cint},ops), - convert(Vector{Cint},children .- 1), - convert(Vector{Cint},beg .- 1), - values) - - # set sense - if sense == :Max - _setSenseMaximize(m) - else - _setSenseMinimize(m) - end -end diff --git a/src/params.jl b/src/params.jl deleted file mode 100644 index ab87c17a..00000000 --- a/src/params.jl +++ /dev/null @@ -1,48 +0,0 @@ -# Helper functions - -# TODO: do this properly -# currently it doesn't check for types, except string and -# the code is horrible doing this zip between names (odd positions) and values (even positions) -# since options look like: "param1", value1, "param2", value2, ... -function setparams!(m::SCIPMathProgModel) - a = m.inner.options - for (name, value) in zip(a[1][1:2:end],a[1][2:2:end]) - setparameter!(m, name, value) - end -end - -function setparameter!(m::SCIPMathProgModel, name::AbstractString, value::Bool) - @assert isascii(name) - _setBoolParam(m, pointer(name), Cint(value)) -end - -function setparameter!(m::SCIPMathProgModel, name::AbstractString, value::Int) - @assert isascii(name) - if _getParamType(m, pointer(name)) == 1 # integer - return _setIntParam(m, pointer(name), Cint(value)) - else - return _setLongintParam(m, pointer(name), Clonglong(value)) - end -end - -function setparameter!(m::SCIPMathProgModel, name::AbstractString, value::Float64) - @assert isascii(name) - _setRealParam(m, pointer(name), Cdouble(value)) -end - -function setparameter!(m::SCIPMathProgModel, name::AbstractString, value::AbstractChar) - @assert isascii(name) - _setCharParam(m, pointer(name), Cchar(value)) -end - -function setparameter!(m::SCIPMathProgModel, name::AbstractString, value::AbstractString) - @assert isascii(name) && isascii(value) - _setStringParam(m, pointer(name), pointer(value)) -end - -# Set a prefix string to be printed with all messages from the solver -function setprefix!(m::SCIPMathProgModel, prefix) - prefix ≠ nothing || return - @assert isascii(prefix) - _setMessagePrefix(m, pointer(prefix)) -end diff --git a/src/scip_wrapper.jl b/src/scip_wrapper.jl deleted file mode 100644 index 08e86840..00000000 --- a/src/scip_wrapper.jl +++ /dev/null @@ -1,9 +0,0 @@ -# direct calls to SCIP - -"Calls SCIPwriteOrigProblem: writes original problem to file" -function _writeOrigProblem(model::SCIPMathProgModel, filename::Cstring, - extension::Cstring, genericnames::Cint) - ccall((:SCIPwriteOrigProblem, libcsip), Cint, - (Ptr{Cvoid}, Cstring, Cstring, Cint), - _getInternalSCIP(model), filename, extension, genericnames) -end diff --git a/src/types.jl b/src/types.jl deleted file mode 100644 index fcaae250..00000000 --- a/src/types.jl +++ /dev/null @@ -1,73 +0,0 @@ -export SCIPSolver - -# Common inner model - -mutable struct SCIPModel - ptr_model::Ptr{Cvoid} - options - lazy_userdata - heur_userdata - - function SCIPModel(options...) - _arr = Array{Ptr{Cvoid}}(undef, 1) - # TODO: check return code (everywhere!) - ccall((:CSIPcreateModel, libcsip), Cint, (Ptr{Ptr{Cvoid}}, ), _arr) - m = new(_arr[1], options) - @assert m.ptr_model != C_NULL - - finalizer(freescip, m) - return m - end -end - -function freescip(m::SCIPModel) - # aCvoid double free - if m.ptr_model != C_NULL - _freeModel(m) - m.ptr_model = C_NULL - end -end - -# Linear Quadratic Model - -struct SCIPLinearQuadraticModel <: MathProgBase.AbstractLinearQuadraticModel - inner::SCIPModel -end - -# Nonlinear Model - -struct SCIPNonlinearModel <: MathProgBase.AbstractNonlinearModel - inner::SCIPModel -end - -# Union type for common behaviour - -const SCIPMathProgModel = Union{SCIPLinearQuadraticModel, SCIPNonlinearModel} - -# Solver - -mutable struct SCIPSolver <: MathProgBase.AbstractMathProgSolver - options - prefix - - function SCIPSolver(kwargs...; prefix=nothing) - new(kwargs, prefix) - end -end - -function MathProgBase.LinearQuadraticModel(s::SCIPSolver) - m = SCIPLinearQuadraticModel(SCIPModel(s.options)) - setparams!(m) - setprefix!(m, s.prefix) - m -end - -function MathProgBase.NonlinearModel(s::SCIPSolver) - m = SCIPNonlinearModel(SCIPModel(s.options)) - setparams!(m) - setprefix!(m, s.prefix) - m -end - -MathProgBase.ConicModel(s::SCIPSolver) = MathProgBase.LPQPtoConicBridge(MathProgBase.LinearQuadraticModel(s)) -MathProgBase.supportedcones(::SCIPSolver) = [:Free,:Zero,:NonNeg,:NonPos,:SOC] diff --git a/test/REQUIRE b/test/REQUIRE index 7d68054c..8b137891 100644 --- a/test/REQUIRE +++ b/test/REQUIRE @@ -1 +1 @@ -JuMP + diff --git a/test/csip_tests.jl b/test/csip_tests.jl deleted file mode 100644 index c69c6260..00000000 --- a/test/csip_tests.jl +++ /dev/null @@ -1,399 +0,0 @@ -# Translation of tests from CSIP wrapper - -solver = SCIPSolver("display/verblevel", 0) - -@testset "LP" begin - m = Model(solver=solver) - @variable(m, x >= 0) - @variable(m, y >= 0) - @constraint(m, 2x + y <= 1.5) - @objective(m, :Min, -x) - - status = solve(m) - @test status == :Optimal - @test getobjectivevalue(m) ≈ -0.75 - @test getvalue(x) ≈ 0.75 - @test getvalue(y) ≈ 0.0 -end - -@testset "MIP" begin - m = Model(solver=solver) - @variable(m, x[1:5], Bin) - @constraint(m, 2x[1] + 8x[2] + 4x[3] + 2x[4] + 5x[5] <= 10) - @objective(m, :Min, -5x[1] - 3x[2] - 2x[3] - 7x[4] - 4x[5]) - - status = solve(m) - @test status == :Optimal - @test getobjectivevalue(m) ≈ -16.0 - @test getvalue(x) ≈ [1.0, 0.0, 0.0, 1.0, 1.0] -end - -@testset "MIP2 (unbounded)" begin - m = Model(solver=solver) - @variable(m, x, Int) - @objective(m, :Min, x) - - status = solve(m, suppress_warnings=true) - @test status == :Unbounded -end - -@testset "MIP3 (infeasible)" begin - m = Model(solver=solver) - @variable(m, x, Int) - @constraint(m, x >= 2) - @constraint(m, x <= 1) - - status = solve(m, suppress_warnings=true) - @test status == :Infeasible -end - -@testset "SOCP" begin - m = Model(solver=solver) - @variable(m, x) - @variable(m, y) - @variable(m, t >= 0) - @constraint(m, x + y >= 1) - @constraint(m, x^2 + y^2 <= t^2) - @objective(m, :Min, t) - - status = solve(m) - @test status == :Optimal - @test getobjectivevalue(m) ≈ sqrt(0.5) atol=1e-5 - @test getvalue(t) ≈ sqrt(0.5) atol=1e-5 - @test getvalue(x) ≈ 0.5 atol=1e-5 - @test getvalue(y) ≈ 0.5 atol=1e-5 -end - -@testset "NLP" begin - m = Model(solver=solver) - @variable(m, x <= 0) - @variable(m, y <= 0) - @variable(m, z) - @NLconstraint(m, z^2 <= 1) - @NLobjective(m, :Max, x + y - z^3) - - status = solve(m) - @test status == :Optimal - @test getobjectivevalue(m) ≈ 1.0 atol=1e-5 - @test getvalue(x) ≈ 0.0 atol=1e-5 - @test getvalue(y) ≈ 0.0 atol=1e-5 - @test getvalue(z) ≈ -1.0 atol=1e-5 -end - -@testset "NLP (no objective)" begin - m = Model(solver=solver) - @variable(m, z) - @NLconstraint(m, z^2 <= 1) - - status = solve(m) - @test status == :Optimal - @test getvalue(z)^2 <= 1.0 + 1e-5 -end - -@testset "quad obj" begin - m = Model(solver=solver) - @variable(m, x) - @variable(m, y) - @constraint(m, x + y >= 1) - @objective(m, :Min, x^2 + y^2) - - status = solve(m) - @test status == :Optimal - @test getobjectivevalue(m) ≈ 0.5 atol=1e-5 - @test getvalue(x) ≈ 0.5 atol=1e-5 - @test getvalue(y) ≈ 0.5 atol=1e-5 -end - -@testset "lazy" begin - m = Model(solver=solver) - @variable(m, x <= 2) - @variable(m, y <= 2) - @objective(m, :Max, 0.5x + y) - - function lazycb(cb) - if getvalue(x) + getvalue(y) > 3.0 - @lazyconstraint(cb, x + y <= 3) - end - end - addlazycallback(m, lazycb) - - status = solve(m) - @test status == :Optimal - @test getobjectivevalue(m) ≈ 2.5 atol=1e-5 - @test getvalue(x) ≈ 1.0 atol=1e-5 - @test getvalue(y) ≈ 2.0 atol=1e-5 -end - -@testset "lazy2 (integer)" begin - m = Model(solver=solver) - @variable(m, x <= 100.5, Int) - @objective(m, :Min, -x) - - function lazycb(cb) - if getvalue(x) > 10.5 - @lazyconstraint(cb, x <= 10.5) - end - end - addlazycallback(m, lazycb) - - status = solve(m) - @test status == :Optimal - @test getobjectivevalue(m) ≈ -10.0 atol=1e-5 - @test getvalue(x) ≈ 10.0 atol=1e-5 -end - -@testset "lazy interrupt" begin - m = Model(solver=solver) - @variable(m, x >= 1.5, Int) - - function lazycb(cb) - return JuMP.StopTheSolver - end - addlazycallback(m, lazycb) - - status = solve(m, suppress_warnings=true) - @test status == :UserLimit -end - -@testset "obj sense" begin - m = Model(solver=solver) - @variable(m, -2.3 <= x <= 4.2) - @objective(m, :Min, x) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ -2.3 - - # change sense and resolve - setobjectivesense(m, :Max) - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 4.2 - - # change sense and resolve - setobjectivesense(m, :Min) - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ -2.3 -end - -@testset "sos1" begin - m = Model(solver=solver) - @variable(m, 0 <= x <= 1) - @variable(m, 0 <= y <= 1) - @variable(m, 0 <= z <= 1) - addSOS1(m, [x, y, z]) - @objective(m, :Max, 2x + 3y + 4z) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 0.0 - @test getvalue(y) ≈ 0.0 - @test getvalue(z) ≈ 1.0 -end - -@testset "sos2" begin - m = Model(solver=solver) - @variable(m, 0 <= x <= 1) - @variable(m, 0 <= y <= 1) - @variable(m, 0 <= z <= 1) - addSOS2(m, [x, y, z]) - @objective(m, :Max, 2x + 3y + 4z) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 0.0 - @test getvalue(y) ≈ 1.0 - @test getvalue(z) ≈ 1.0 -end - -@testset "sos1 & sos2" begin - m = Model(solver=solver) - @variable(m, 0 <= x <= 1) - @variable(m, 0 <= y <= 1) - @variable(m, 0 <= z <= 1) - addSOS1(m, [ y, z]) - addSOS2(m, [x, y, z]) - @objective(m, :Max, 2x + 3y + 4z) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 1.0 - @test getvalue(y) ≈ 1.0 - @test getvalue(z) ≈ 0.0 -end - -# not adding test: manythings -# not adding test: doublelazy - -@testset "changeprob" begin - m = Model(solver=solver) - @variable(m, x, Bin) - @variable(m, y, Bin) - @variable(m, z, Bin) # have to add it to original model, - # since addvar! not implemented in SCIP.jl - @constraint(m, x + y <= 1) - @objective(m, :Max, x + 2y) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 0.0 - @test getvalue(y) ≈ 1.0 - - # now change it - @constraint(m, x + y + z <= 2) - @constraint(m, y + z <= 1) - @objective(m, :Max, x + 2y + 2z) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 1.0 - @test getvalue(y) ≈ 0.0 - @test getvalue(z) ≈ 1.0 -end - -@testset "changequadprob" begin - m = Model(solver=solver) - @variable(m, x) - @variable(m, y) - @constraint(m, x + y >= 1) - @objective(m, :Min, x^2 + y^2) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 0.5 atol=1e-5 - @test getvalue(y) ≈ 0.5 atol=1e-5 - - # now change it - @constraint(m, x + y == 1) - @objective(m, :Max, -x^2 + y) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ -0.5 atol=1e-5 - @test getvalue(y) ≈ 1.5 atol=1e-5 -end - -@testset "changevartype" begin - m = Model(solver=solver) - @variable(m, 0 <= x <= 9) - @variable(m, 0 <= y <= 9) - @constraint(m, x + y >= 1.5) - @objective(m, :Min, 2x + 3y) - - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 1.5 - @test getvalue(y) ≈ 0.0 - - # resolve with x as integer - setcategory(x, :Int) - status = solve(m) - @test status == :Optimal - @test getvalue(x) ≈ 1.0 - @test getvalue(y) ≈ 0.5 -end - -@testset "initialsol" begin - s = SCIPSolver("display/verblevel", 0, - "limits/solutions", 1, - "heuristics/trivial/freq", -1) - m = Model(solver=s) - @variable(m, 10 <= x <= 100, Int, start=23) - @objective(m, :Min, 2x) - - status = solve(m, suppress_warnings=true) - @test status == :UserLimit - @test getobjectivevalue(m) ≈ 2*23 - @test getvalue(x) ≈ 23 -end - -@testset "initialsol NLP" begin - s = SCIPSolver("display/verblevel", 0, - "limits/solutions", 1, - "heuristics/trivial/freq", -1) - m = Model(solver=s) - @variable(m, x <= 0, start=0) - @variable(m, y <= 0, start=-1) - @variable(m, z, start=-0.5) - @NLconstraint(m, z^2 <= 1) - @NLobjective(m, :Max, x + y - z^3) - - status = solve(m, suppress_warnings=true) - @test status == :UserLimit - @test getobjectivevalue(m) ≈ 0 - 1.0 + 0.5^3 - @test getvalue(x) ≈ 0.0 - @test getvalue(y) ≈ -1.0 - @test getvalue(z) ≈ -0.5 -end - -@testset "initialsol partial" begin - s = SCIPSolver("display/verblevel", 0, - "limits/solutions", 1, - "heuristics/trivial/freq", -1) - m = Model(solver=s) - @variable(m, 0 <= x <= 2, Int, start=1) - @variable(m, 0 <= y <= 2, Int) - @constraint(m, x + y == 2) - @objective(m, :Max, x + 2y) - - status = solve(m, suppress_warnings=true) - @test status == :UserLimit - @test getobjectivevalue(m) ≈ 3 - @test getvalue(x) ≈ 1 - @test getvalue(y) ≈ 1 -end - -@testset "initialsol NLP partial" begin - s = SCIPSolver("display/verblevel", 0, - "limits/solutions", 1, - "heuristics/trivial/freq", -1) - m = Model(solver=s) - @variable(m, x <= 0) - @variable(m, y <= 0, start=-1) - @variable(m, z, start=-0.5) - @NLconstraint(m, z^2 <= 1) - @NLobjective(m, :Max, x + y - z^3) - - status = solve(m, suppress_warnings=true) - @test status == :UserLimit - @test getobjectivevalue(m) ≈ 0 - 1.0 + 0.5^3 - @test getvalue(x) ≈ 0.0 - @test getvalue(y) ≈ -1.0 - @test getvalue(z) ≈ -0.5 -end - -@testset "heurcb" begin - s = SCIPSolver("display/verblevel", 0, - "limits/solutions", 1, - "heuristics/feaspump/freq", -1, - "heuristics/randrounding/freq", -1, - "heuristics/rounding/freq", -1, - "heuristics/shiftandpropagate/freq", -1, - "heuristics/shifting/freq", -1, - "heuristics/simplerounding/freq", -1, - "heuristics/trivial/freq", -1, - "presolving/maxrounds", 0, - "separating/maxroundsroot", 0) - m = Model(solver=s) - @variable(m, 0 <= x <= 3, Int) - @variable(m, 0 <= y <= 3, Int) - @constraint(m, 2x + 3y >= 6) - @constraint(m, 3x + 2y >= 6) - @objective(m, :Min, x + y) - - function heurcb(cb) - setsolutionvalue(cb, x, 2.0) - setsolutionvalue(cb, y, 2.0) - addsolution(cb) - end - addheuristiccallback(m, heurcb) - - status = solve(m, suppress_warnings=true) - @test status == :UserLimit - @test getvalue(x) ≈ 2.0 - @test getvalue(y) ≈ 2.0 -end - -# not adding test: params (not available through SCIP.jl) -# not adding test: prefix (only about output) diff --git a/test/more_tests.jl b/test/more_tests.jl deleted file mode 100644 index 40035879..00000000 --- a/test/more_tests.jl +++ /dev/null @@ -1,108 +0,0 @@ -# todo: find a meaningful name for this file -@testset "testing more mpb interface methods" begin - m = MathProgBase.LinearQuadraticModel(SCIPSolver("display/verblevel", 0)) - - # take a bit more time integer problem - A = [314 867 860; 87 875 -695] - l = [-10, -1000, -1000] - u = [Inf Inf Inf] - c = [-1,1,1] - lb = [40600 -92375] - ub = lb - MathProgBase.loadproblem!(m, A, l, u, c, lb, ub, :Min) - @test MathProgBase.numconstr(m) == 2 - @test MathProgBase.numvar(m) == 3 - - MathProgBase.setvartype!(m, [:Int, :Int, :Int]) - MathProgBase.optimize!(m) - @test MathProgBase.status(m) == :Optimal - @test MathProgBase.getsolvetime(m) >= 0.001 - @test MathProgBase.getsolution(m) ≈ [750, -200, -25] -end - -modelPath = joinpath(dirname(@__FILE__), "model") - -@testset "test writeproblem" begin - m = Model(solver=SCIPSolver("display/verblevel", 0)) - @variable(m, x >= 2) - @constraint(m, 3x <= 40) - @objective(m, :Max, 5x) - solve(m) - - cipfname = modelPath * "test.cip" - MathProgBase.writeproblem(internalmodel(m), cipfname) - - cipstr = String[ - "STATISTICS", - " Problem name : name", - " Variables : 1 (0 binary, 0 integer, 0 implicit integer, 1 continuous)", - " Constraints : 1 initial, 1 maximal", - "OBJECTIVE", - " Sense : maximize", - "VARIABLES", - " [continuous] <_var0_>: obj=5, original bounds=[2,+inf]", - "CONSTRAINTS", - " [linear] : +3<_var0_>[C] <= 40;", - "END"] - - open(cipfname) do file - lineno = 1 - while !eof(file) - line = readline(file) - @test strip(line) == strip(cipstr[lineno]) - lineno += 1 - end - end - rm(cipfname) # clean up for future test runs -end - -@testset "test_#49_initialsol_nlp" begin - m = Model(solver=SCIPSolver("display/verblevel", 0, - "heuristics/trivial/freq", -1, - "limits/solutions", 1)) - - @variable(m, 0 <= x[1:3] <= 10, start=5.0) - @variable(m, y, Bin, start=1.0) - - @NLconstraint(m, x[1] + x[2] <= x[3]*y) - @constraint(m, x[1] - x[2] == 0) - - @objective(m, Min, x[1]) - - # This makes the initial point feasible - setvalue(x[3], 10.0) - - solve(m, suppress_warnings=true) - - @test getvalue(x)[3] == 10.0 -end - -@testset "test_incomplete_warmstart" begin - m = Model(solver=SCIPSolver("display/verblevel", 0, - "heuristics/trivial/freq", -1, - "limits/solutions", 1)) - - @variable(m, 0 <= x <= 2, Int, start=1.0) - @variable(m, 0 <= y <= 2) - - @constraint(m, x + y == 2) - - @objective(m, Max, x + 2y) - - solve(m, suppress_warnings=true) - - @test getvalue(x) ≈ 1.0 - @test getvalue(y) ≈ 1.0 -end - -@testset "test_#67_nlp_without_obj" begin - m = Model(solver=SCIPSolver("display/verblevel", 0)) - @variable(m, -5 <= x <= 5) - @NLconstraint(m, x <= 2) - - solve(m) - xval = getvalue(x) - - @test xval <= 2 + 1e-4 - @test xval >= -5 - 1e-4 -end diff --git a/test/mpb_tests.jl b/test/mpb_tests.jl deleted file mode 100644 index 5658fb9c..00000000 --- a/test/mpb_tests.jl +++ /dev/null @@ -1,27 +0,0 @@ -testdir = joinpath(dirname(pathof(MathProgBase)), "..", "test") -solver = SCIPSolver("display/verblevel", 0) - -## can't test these because SCIP does not give access to dual solution -# include(joinpath(testdir, "linprog.jl")) -# linprogtest(solver) - -include(joinpath(testdir, "mixintprog.jl")) -mixintprogtest(solver) - -## can't use setquadobj! or get duals -include(joinpath(testdir, "quadprog.jl")) -# quadprogtest(solver) -# qpdualtest(solver) -socptest(solver) - -## can't use tests based on NLP evalutors (only expr graphs) -# include(joinpath(testdir, "nlp.jl")) -# nlptest(solver) -# nlptest_nohessian(solver) -# convexnlptest(solver) -# rosenbrocktest(solver) - -## can't test methods that are not implemented with SCIP.jl -# include(joinpath(testdir, "linproginterface.jl")) -# linprogsolvertest(solver) -# linprogsolvertestextra(solver) diff --git a/test/runtests.jl b/test/runtests.jl index 72ec93e7..cc57e86a 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,16 +1 @@ using Test -using SCIP -using MathProgBase -using JuMP - -@testset "MathProgBase tests" begin - include("mpb_tests.jl") -end - -@testset "CSIP tests" begin - include("csip_tests.jl") -end - -@testset "Other tests" begin - include("more_tests.jl") -end diff --git a/travis_docker_env.list b/travis_docker_env.list deleted file mode 100644 index 6fed1146..00000000 --- a/travis_docker_env.list +++ /dev/null @@ -1,10 +0,0 @@ -# environment variables that are passed from Travis to Docker -DOCUMENTER_KEY -TRAVIS_BRANCH -TRAVIS_PULL_REQUEST -TRAVIS_REPO_SLUG -TRAVIS_TAG -TRAVIS_OS_NAME -TRAVIS_JULIA_VERSION -# comment this out to debug Documenter.jl -# DOCUMENTER_DEBUG=true diff --git a/travis_docker_test_script.sh b/travis_docker_test_script.sh deleted file mode 100755 index 8cd18b8e..00000000 --- a/travis_docker_test_script.sh +++ /dev/null @@ -1,25 +0,0 @@ -#!/bin/bash - -# the first and only argument to the script is the version -JULIAVER=$1 -JULIABIN=/test/julia-$JULIAVER/bin/julia -PKGNAME="SCIP" - -## install the image (when necessary) -/test/install-julia.sh $JULIAVER - -cd /mnt && if [[ -a .git/shallow ]]; then git fetch --unshallow; fi - -# install SCIP -wget http://scip.zib.de/download/release/SCIPOptSuite-6.0.0-Linux.deb -dpkg -i SCIPOptSuite-6.0.0-Linux.deb -export SCIPOPTDIR="/usr" - -# run tests -$JULIABIN -e "using Pkg; Pkg.clone(\"/mnt/\", \"$PKGNAME\"); Pkg.build(\"$PKGNAME\"); Pkg.test(\"$PKGNAME\"; coverage=true)" -TEST_EXIT=$? # return with this - -# save coverage results back to host -PKGDIR=`$JULIABIN -e "using Pkg; print(dirname(pathof($PKGNAME)))"` -rsync -mav --include="*/" --include="*.cov" --exclude="*" $PKGDIR/ /mnt/ -exit $TEST_EXIT From 91dbc6840788aa430efd3d9ed6d5adbf2b151c5d Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 22:01:14 +0100 Subject: [PATCH 14/82] add deps/build.jl - inspired by Gurobi.jl - seems to work when `/usr/lib/libscip.so` exists. --- REQUIRE | 1 + deps/build.jl | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/REQUIRE b/REQUIRE index 05b5ab4c..1ca718e6 100644 --- a/REQUIRE +++ b/REQUIRE @@ -1 +1,2 @@ julia 1.0 +Compat diff --git a/deps/build.jl b/deps/build.jl index 5ee96c53..3e52e16f 100644 --- a/deps/build.jl +++ b/deps/build.jl @@ -1 +1,38 @@ +using Compat using Libdl + +depsfile = joinpath(dirname(@__FILE__), "deps.jl") +if isfile(depsfile) + rm(depsfile) +end + +function write_depsfile(path) + f = open(depsfile, "w") + println(f, "const libscip = \"$path\"") + close(f) +end + +libname = "libscip.so" +paths_to_try = [libname] + +if haskey(ENV, "SCIPOPTDIR") + if Compat.Sys.isunix() + push!(paths_to_try, joinpath(ENV["SCIPOPTDIR"], "lib", libname)) + end +end + +found = false +for l in paths_to_try + d = Libdl.dlopen_e(l) + if d != C_NULL + global found = true + write_depsfile(l) + break + end +end + +if !found && !haskey(ENV, "SCIP_JL_SKIP_LIB_CHECK") + error("Unable to locate SCIP installation. " * + "Note that this must be downloaded separately from scip.zib.de. " * + "Please set the environment variable SCIPOPTDIR to SCIP's installation path.") +end From 9f9b2be3b2f31c63fec06d8547b952d88a4a19b4 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 22:21:08 +0100 Subject: [PATCH 15/82] include all wrappers into another file --- src/SCIP.jl | 3 +++ src/wrapper.jl | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+) create mode 100644 src/wrapper.jl diff --git a/src/SCIP.jl b/src/SCIP.jl index ebd58aa4..ee0daeb0 100644 --- a/src/SCIP.jl +++ b/src/SCIP.jl @@ -1,3 +1,6 @@ module SCIP +# wrapper of SCIP library +include("wrapper.jl") + end diff --git a/src/wrapper.jl b/src/wrapper.jl new file mode 100644 index 00000000..4f469fdd --- /dev/null +++ b/src/wrapper.jl @@ -0,0 +1,54 @@ +wrap(base) = joinpath("wrapper", base * ".jl") + +# used by Clang.jl +include(wrap("ctypes")) +include(wrap("CEnum")) +using .CEnum + +# all type definitions +include(wrap("commons")) + +# wrappers for scip headers +include(wrap("scip_bandit")) +include(wrap("scip_benders")) +include(wrap("scip_branch")) +include(wrap("scip_compr")) +include(wrap("scip_concurrent")) +include(wrap("scip_conflict")) +include(wrap("scip_cons")) +include(wrap("scip_copy")) +include(wrap("scip_cut")) +include(wrap("scip_datastructures")) +include(wrap("scip_debug")) +include(wrap("scip_dialog")) +include(wrap("scip_disp")) +include(wrap("scip_event")) +include(wrap("scip_expr")) +include(wrap("scip_general")) +include(wrap("scip_heur")) +include(wrap("scip_lp")) +include(wrap("scip_mem")) +include(wrap("scip_message")) +include(wrap("scip_nlp")) +include(wrap("scip_nodesel")) +include(wrap("scip_nonlinear")) +include(wrap("scip_numerics")) +include(wrap("scip_param")) +include(wrap("scip_presol")) +include(wrap("scip_pricer")) +include(wrap("scip_probing")) +include(wrap("scip_prob")) +include(wrap("scip_prop")) +include(wrap("scip_randnumgen")) +include(wrap("scip_reader")) +include(wrap("scip_relax")) +include(wrap("scip_reopt")) +include(wrap("scip_sepa")) +include(wrap("scip_sol")) +include(wrap("scip_solve")) +include(wrap("scip_solvingstats")) +include(wrap("scip_table")) +include(wrap("scip_timing")) +include(wrap("scip_tree")) +include(wrap("scip_validation")) +include(wrap("scip_var")) From fbc281fbc9a62bc9bfd58de891d7149ad0c05a1a Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 22:36:33 +0100 Subject: [PATCH 16/82] add some manually wrapped constants :-( --- src/wrapper.jl | 1 + src/wrapper/manual_commons.jl | 38 +++++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 src/wrapper/manual_commons.jl diff --git a/src/wrapper.jl b/src/wrapper.jl index 4f469fdd..ae8cf839 100644 --- a/src/wrapper.jl +++ b/src/wrapper.jl @@ -6,6 +6,7 @@ include(wrap("CEnum")) using .CEnum # all type definitions +include(wrap("manual_commons")) include(wrap("commons")) # wrappers for scip headers diff --git a/src/wrapper/manual_commons.jl b/src/wrapper/manual_commons.jl new file mode 100644 index 00000000..345325ee --- /dev/null +++ b/src/wrapper/manual_commons.jl @@ -0,0 +1,38 @@ +# TODO: created manually, better to improve on wrapper generator! + +const SCIP_EVENTTYPE_DISABLED = UInt64(0x00000000) +const SCIP_EVENTTYPE_VARADDED = UInt64(0x00000001) +const SCIP_EVENTTYPE_VARDELETED = UInt64(0x00000002) +const SCIP_EVENTTYPE_VARFIXED = UInt64(0x00000004) +const SCIP_EVENTTYPE_VARUNLOCKED = UInt64(0x00000008) +const SCIP_EVENTTYPE_OBJCHANGED = UInt64(0x00000010) +const SCIP_EVENTTYPE_GLBCHANGED = UInt64(0x00000020) +const SCIP_EVENTTYPE_GUBCHANGED = UInt64(0x00000040) +const SCIP_EVENTTYPE_LBTIGHTENED = UInt64(0x00000080) +const SCIP_EVENTTYPE_LBRELAXED = UInt64(0x00000100) +const SCIP_EVENTTYPE_UBTIGHTENED = UInt64(0x00000200) +const SCIP_EVENTTYPE_UBRELAXED = UInt64(0x00000400) +const SCIP_EVENTTYPE_GHOLEADDED = UInt64(0x00000800) +const SCIP_EVENTTYPE_GHOLEREMOVED = UInt64(0x00001000) +const SCIP_EVENTTYPE_LHOLEADDED = UInt64(0x00002000) +const SCIP_EVENTTYPE_LHOLEREMOVED = UInt64(0x00004000) +const SCIP_EVENTTYPE_IMPLADDED = UInt64(0x00008000) +const SCIP_EVENTTYPE_PRESOLVEROUND = UInt64(0x00010000) +const SCIP_EVENTTYPE_NODEFOCUSED = UInt64(0x00020000) +const SCIP_EVENTTYPE_NODEFEASIBLE = UInt64(0x00040000) +const SCIP_EVENTTYPE_NODEINFEASIBLE = UInt64(0x00080000) +const SCIP_EVENTTYPE_NODEBRANCHED = UInt64(0x00100000) +const SCIP_EVENTTYPE_FIRSTLPSOLVED = UInt64(0x00200000) +const SCIP_EVENTTYPE_LPSOLVED = UInt64(0x00400000) +const SCIP_EVENTTYPE_POORSOLFOUND = UInt64(0x00800000) +const SCIP_EVENTTYPE_BESTSOLFOUND = UInt64(0x01000000) +const SCIP_EVENTTYPE_ROWADDEDSEPA = UInt64(0x02000000) +const SCIP_EVENTTYPE_ROWDELETEDSEPA = UInt64(0x04000000) +const SCIP_EVENTTYPE_ROWADDEDLP = UInt64(0x08000000) +const SCIP_EVENTTYPE_ROWDELETEDLP = UInt64(0x10000000) +const SCIP_EVENTTYPE_ROWCOEFCHANGED = UInt64(0x20000000) +const SCIP_EVENTTYPE_ROWCONSTCHANGED = UInt64(0x40000000) +const SCIP_EVENTTYPE_ROWSIDECHANGED = UInt64(0x80000000) +const SCIP_EVENTTYPE_SYNC = UInt64(0x100000000) + +const PRIx64 = "llx" From a58373eac5d662241fb55d69e290f5c4d45b1e22 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 22:43:59 +0100 Subject: [PATCH 17/82] rename type SCIP to SCIP_, avoid name conflict with module --- src/wrapper/commons.jl | 2 +- src/wrapper/scip_bandit.jl | 8 +- src/wrapper/scip_benders.jl | 86 ++++---- src/wrapper/scip_branch.jl | 98 ++++----- src/wrapper/scip_compr.jl | 24 +-- src/wrapper/scip_concurrent.jl | 14 +- src/wrapper/scip_conflict.jl | 52 ++--- src/wrapper/scip_cons.jl | 158 +++++++------- src/wrapper/scip_copy.jl | 52 ++--- src/wrapper/scip_cut.jl | 60 +++--- src/wrapper/scip_datastructures.jl | 76 +++---- src/wrapper/scip_debug.jl | 4 +- src/wrapper/scip_dialog.jl | 20 +- src/wrapper/scip_disp.jl | 10 +- src/wrapper/scip_event.jl | 36 ++-- src/wrapper/scip_expr.jl | 8 +- src/wrapper/scip_general.jl | 38 ++-- src/wrapper/scip_heur.jl | 26 +-- src/wrapper/scip_lp.jl | 182 ++++++++-------- src/wrapper/scip_mem.jl | 18 +- src/wrapper/scip_message.jl | 10 +- src/wrapper/scip_nlp.jl | 150 ++++++------- src/wrapper/scip_nodesel.jl | 28 +-- src/wrapper/scip_nonlinear.jl | 18 +- src/wrapper/scip_numerics.jl | 172 +++++++-------- src/wrapper/scip_param.jl | 94 ++++---- src/wrapper/scip_presol.jl | 24 +-- src/wrapper/scip_pricer.jl | 30 +-- src/wrapper/scip_prob.jl | 164 +++++++------- src/wrapper/scip_probing.jl | 54 ++--- src/wrapper/scip_prop.jl | 34 +-- src/wrapper/scip_randnumgen.jl | 8 +- src/wrapper/scip_reader.jl | 18 +- src/wrapper/scip_relax.jl | 24 +-- src/wrapper/scip_reopt.jl | 38 ++-- src/wrapper/scip_sepa.jl | 26 +-- src/wrapper/scip_sol.jl | 144 ++++++------- src/wrapper/scip_solve.jl | 38 ++-- src/wrapper/scip_solvingstats.jl | 246 ++++++++++----------- src/wrapper/scip_table.jl | 8 +- src/wrapper/scip_timing.jl | 36 ++-- src/wrapper/scip_tree.jl | 58 ++--- src/wrapper/scip_validation.jl | 2 +- src/wrapper/scip_var.jl | 330 ++++++++++++++--------------- 44 files changed, 1363 insertions(+), 1363 deletions(-) diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index 81863115..fdc03b3e 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -835,7 +835,7 @@ const SCIP_RESULT = SCIP_Result const SCIP_RETCODE = SCIP_Retcode const Scip = Cvoid -const SCIP = Scip +const SCIP_ = Scip # Skipping MacroDefinition: SCIP_DECL_SEPACOPY ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) # Skipping MacroDefinition: SCIP_DECL_SEPAFREE ( x ) SCIP_RETCODE x ( SCIP * scip , SCIP_SEPA * sepa ) diff --git a/src/wrapper/scip_bandit.jl b/src/wrapper/scip_bandit.jl index a7c90b55..9dd215be 100644 --- a/src/wrapper/scip_bandit.jl +++ b/src/wrapper/scip_bandit.jl @@ -3,17 +3,17 @@ function SCIPincludeBanditvtable(scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) - ccall((:SCIPincludeBanditvtable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDITVTABLE}}, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) + ccall((:SCIPincludeBanditvtable, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BANDITVTABLE}}, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) end function SCIPfindBanditvtable(scip, name) - ccall((:SCIPfindBanditvtable, libscip), Ptr{SCIP_BANDITVTABLE}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindBanditvtable, libscip), Ptr{SCIP_BANDITVTABLE}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPfreeBandit(scip, bandit) - ccall((:SCIPfreeBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}), scip, bandit) + ccall((:SCIPfreeBandit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BANDIT}}), scip, bandit) end function SCIPresetBandit(scip, bandit, priorities, seed) - ccall((:SCIPresetBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BANDIT}, Ptr{Cdouble}, UInt32), scip, bandit, priorities, seed) + ccall((:SCIPresetBandit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BANDIT}, Ptr{Cdouble}, UInt32), scip, bandit, priorities, seed) end diff --git a/src/wrapper/scip_benders.jl b/src/wrapper/scip_benders.jl index bf59f198..0cc02456 100644 --- a/src/wrapper/scip_benders.jl +++ b/src/wrapper/scip_benders.jl @@ -3,173 +3,173 @@ function SCIPincludeBenders(scip, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre, bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex, benderssolvesub, benderspostsolve, bendersfreesub, bendersdata) - ccall((:SCIPincludeBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre, bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex, benderssolvesub, benderspostsolve, bendersfreesub, bendersdata) + ccall((:SCIPincludeBenders, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, benderscopy, bendersfree, bendersinit, bendersexit, bendersinitpre, bendersexitpre, bendersinitsol, bendersexitsol, bendersgetvar, benderscreatesub, benderspresubsolve, benderssolvesubconvex, benderssolvesub, benderspostsolve, bendersfreesub, bendersdata) end function SCIPincludeBendersBasic(scip, bendersptr, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, bendersgetvar, benderscreatesub, bendersdata) - ccall((:SCIPincludeBendersBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BENDERS}}, Cstring, Cstring, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, bendersptr, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, bendersgetvar, benderscreatesub, bendersdata) + ccall((:SCIPincludeBendersBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BENDERS}}, Cstring, Cstring, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, bendersptr, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, bendersgetvar, benderscreatesub, bendersdata) end function SCIPsetBendersCopy(scip, benders, benderscopy) - ccall((:SCIPsetBendersCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderscopy) + ccall((:SCIPsetBendersCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderscopy) end function SCIPsetBendersFree(scip, benders, bendersfree) - ccall((:SCIPsetBendersFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersfree) + ccall((:SCIPsetBendersFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersfree) end function SCIPsetBendersInit(scip, benders, bendersinit) - ccall((:SCIPsetBendersInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinit) + ccall((:SCIPsetBendersInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinit) end function SCIPsetBendersExit(scip, benders, bendersexit) - ccall((:SCIPsetBendersExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexit) + ccall((:SCIPsetBendersExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexit) end function SCIPsetBendersInitpre(scip, benders, bendersinitpre) - ccall((:SCIPsetBendersInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitpre) + ccall((:SCIPsetBendersInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitpre) end function SCIPsetBendersExitpre(scip, benders, bendersexitpre) - ccall((:SCIPsetBendersExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitpre) + ccall((:SCIPsetBendersExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitpre) end function SCIPsetBendersInitsol(scip, benders, bendersinitsol) - ccall((:SCIPsetBendersInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitsol) + ccall((:SCIPsetBendersInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitsol) end function SCIPsetBendersExitsol(scip, benders, bendersexitsol) - ccall((:SCIPsetBendersExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitsol) + ccall((:SCIPsetBendersExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitsol) end function SCIPsetBendersPresubsolve(scip, benders, benderspresubsolve) - ccall((:SCIPsetBendersPresubsolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderspresubsolve) + ccall((:SCIPsetBendersPresubsolve, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderspresubsolve) end function SCIPsetBendersSolveAndFreesub(scip, benders, benderssolvesubconvex, benderssolvesub, bendersfreesub) - ccall((:SCIPsetBendersSolveAndFreesub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, benders, benderssolvesubconvex, benderssolvesub, bendersfreesub) + ccall((:SCIPsetBendersSolveAndFreesub, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, benders, benderssolvesubconvex, benderssolvesub, bendersfreesub) end function SCIPsetBendersPostsolve(scip, benders, benderspostsolve) - ccall((:SCIPsetBendersPostsolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderspostsolve) + ccall((:SCIPsetBendersPostsolve, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderspostsolve) end function SCIPfindBenders(scip, name) - ccall((:SCIPfindBenders, libscip), Ptr{SCIP_BENDERS}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindBenders, libscip), Ptr{SCIP_BENDERS}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetBenders(scip) - ccall((:SCIPgetBenders, libscip), Ptr{Ptr{SCIP_BENDERS}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetBenders, libscip), Ptr{Ptr{SCIP_BENDERS}}, (Ptr{SCIP_},), scip) end function SCIPgetNBenders(scip) - ccall((:SCIPgetNBenders, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNBenders, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNActiveBenders(scip) - ccall((:SCIPgetNActiveBenders, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNActiveBenders, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPactivateBenders(scip, benders, nsubproblems) - ccall((:SCIPactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, nsubproblems) + ccall((:SCIPactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Cint), scip, benders, nsubproblems) end function SCIPdeactivateBenders(scip, benders) - ccall((:SCIPdeactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) + ccall((:SCIPdeactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}), scip, benders) end function SCIPsetBendersPriority(scip, benders, priority) - ccall((:SCIPsetBendersPriority, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, priority) + ccall((:SCIPsetBendersPriority, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Cint), scip, benders, priority) end function SCIPsolveBendersSubproblems(scip, benders, sol, result, infeasible, auxviol, type, checkint) - ccall((:SCIPsolveBendersSubproblems, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}, Ptr{UInt32}, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32), scip, benders, sol, result, infeasible, auxviol, type, checkint) + ccall((:SCIPsolveBendersSubproblems, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}, Ptr{UInt32}, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32), scip, benders, sol, result, infeasible, auxviol, type, checkint) end function SCIPgetBendersMasterVar(scip, benders, var, mappedvar) - ccall((:SCIPgetBendersMasterVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, benders, var, mappedvar) + ccall((:SCIPgetBendersMasterVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, benders, var, mappedvar) end function SCIPgetBendersSubproblemVar(scip, benders, var, mappedvar, probnumber) - ccall((:SCIPgetBendersSubproblemVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, benders, var, mappedvar, probnumber) + ccall((:SCIPgetBendersSubproblemVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, benders, var, mappedvar, probnumber) end function SCIPgetBendersNSubproblems(scip, benders) - ccall((:SCIPgetBendersNSubproblems, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) + ccall((:SCIPgetBendersNSubproblems, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}), scip, benders) end function SCIPaddBendersSubproblem(scip, benders, subproblem) - ccall((:SCIPaddBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP}), scip, benders, subproblem) + ccall((:SCIPaddBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_}), scip, benders, subproblem) end function SCIPsetupBendersSubproblem(scip, benders, sol, probnumber) - ccall((:SCIPsetupBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) + ccall((:SCIPsetupBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) end function SCIPsolveBendersSubproblem(scip, benders, sol, probnumber, infeasible, type, solvecip, objective) - ccall((:SCIPsolveBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32, Ptr{Cdouble}), scip, benders, sol, probnumber, infeasible, type, solvecip, objective) + ccall((:SCIPsolveBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32, Ptr{Cdouble}), scip, benders, sol, probnumber, infeasible, type, solvecip, objective) end function SCIPfreeBendersSubproblem(scip, benders, probnumber) - ccall((:SCIPfreeBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, probnumber) + ccall((:SCIPfreeBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Cint), scip, benders, probnumber) end function SCIPcheckBendersSubproblemOptimality(scip, benders, sol, probnumber, optimal) - ccall((:SCIPcheckBendersSubproblemOptimality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}), scip, benders, sol, probnumber, optimal) + ccall((:SCIPcheckBendersSubproblemOptimality, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{UInt32}), scip, benders, sol, probnumber, optimal) end function SCIPgetBendersAuxiliaryVarVal(scip, benders, sol, probnumber) - ccall((:SCIPgetBendersAuxiliaryVarVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) + ccall((:SCIPgetBendersAuxiliaryVarVal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint), scip, benders, sol, probnumber) end function SCIPcomputeBendersSubproblemLowerbound(scip, benders, probnumber, lowerbound, infeasible) - ccall((:SCIPcomputeBendersSubproblemLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{Cdouble}, Ptr{UInt32}), scip, benders, probnumber, lowerbound, infeasible) + ccall((:SCIPcomputeBendersSubproblemLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Cint, Ptr{Cdouble}, Ptr{UInt32}), scip, benders, probnumber, lowerbound, infeasible) end function SCIPmergeBendersSubproblemIntoMaster(scip, benders, varmap, consmap, probnumber) - ccall((:SCIPmergeBendersSubproblemIntoMaster, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cint), scip, benders, varmap, consmap, probnumber) + ccall((:SCIPmergeBendersSubproblemIntoMaster, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cint), scip, benders, varmap, consmap, probnumber) end function SCIPincludeBenderscut(scip, benders, name, desc, priority, islpcut, benderscutcopy, benderscutfree, benderscutinit, benderscutexit, benderscutinitsol, benderscutexitsol, benderscutexec, benderscutdata) - ccall((:SCIPincludeBenderscut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, name, desc, priority, islpcut, benderscutcopy, benderscutfree, benderscutinit, benderscutexit, benderscutinitsol, benderscutexitsol, benderscutexec, benderscutdata) + ccall((:SCIPincludeBenderscut, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, name, desc, priority, islpcut, benderscutcopy, benderscutfree, benderscutinit, benderscutexit, benderscutinitsol, benderscutexitsol, benderscutexec, benderscutdata) end function SCIPincludeBenderscutBasic(scip, benders, benderscutptr, name, desc, priority, islpcut, benderscutexec, benderscutdata) - ccall((:SCIPincludeBenderscutBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Ptr{SCIP_BENDERSCUT}}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, benderscutptr, name, desc, priority, islpcut, benderscutexec, benderscutdata) + ccall((:SCIPincludeBenderscutBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Ptr{Ptr{SCIP_BENDERSCUT}}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, benderscutptr, name, desc, priority, islpcut, benderscutexec, benderscutdata) end function SCIPsetBenderscutCopy(scip, benderscut, benderscutcopy) - ccall((:SCIPsetBenderscutCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutcopy) + ccall((:SCIPsetBenderscutCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutcopy) end function SCIPsetBenderscutFree(scip, benderscut, benderscutfree) - ccall((:SCIPsetBenderscutFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutfree) + ccall((:SCIPsetBenderscutFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutfree) end function SCIPsetBenderscutInit(scip, benderscut, benderscutinit) - ccall((:SCIPsetBenderscutInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinit) + ccall((:SCIPsetBenderscutInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinit) end function SCIPsetBenderscutExit(scip, benderscut, benderscutexit) - ccall((:SCIPsetBenderscutExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexit) + ccall((:SCIPsetBenderscutExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexit) end function SCIPsetBenderscutInitsol(scip, benderscut, benderscutinitsol) - ccall((:SCIPsetBenderscutInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinitsol) + ccall((:SCIPsetBenderscutInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinitsol) end function SCIPsetBenderscutExitsol(scip, benderscut, benderscutexitsol) - ccall((:SCIPsetBenderscutExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexitsol) + ccall((:SCIPsetBenderscutExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexitsol) end function SCIPsetBenderscutPriority(scip, benderscut, priority) - ccall((:SCIPsetBenderscutPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Cint), scip, benderscut, priority) + ccall((:SCIPsetBenderscutPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Cint), scip, benderscut, priority) end function SCIPstoreBenderscutCons(scip, benderscut, cons) - ccall((:SCIPstoreBenderscutCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_CONS}), scip, benderscut, cons) + ccall((:SCIPstoreBenderscutCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_CONS}), scip, benderscut, cons) end function SCIPstoreBenderscutCut(scip, benderscut, cut) - ccall((:SCIPstoreBenderscutCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_ROW}), scip, benderscut, cut) + ccall((:SCIPstoreBenderscutCut, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_ROW}), scip, benderscut, cut) end diff --git a/src/wrapper/scip_branch.jl b/src/wrapper/scip_branch.jl index 6af42520..b38f37a6 100644 --- a/src/wrapper/scip_branch.jl +++ b/src/wrapper/scip_branch.jl @@ -3,197 +3,197 @@ function SCIPincludeBranchrule(scip, name, desc, priority, maxdepth, maxbounddist, branchcopy, branchfree, branchinit, branchexit, branchinitsol, branchexitsol, branchexeclp, branchexecext, branchexecps, branchruledata) - ccall((:SCIPincludeBranchrule, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BRANCHRULEDATA}), scip, name, desc, priority, maxdepth, maxbounddist, branchcopy, branchfree, branchinit, branchexit, branchinitsol, branchexitsol, branchexeclp, branchexecext, branchexecps, branchruledata) + ccall((:SCIPincludeBranchrule, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Cint, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BRANCHRULEDATA}), scip, name, desc, priority, maxdepth, maxbounddist, branchcopy, branchfree, branchinit, branchexit, branchinitsol, branchexitsol, branchexeclp, branchexecext, branchexecps, branchruledata) end function SCIPincludeBranchruleBasic(scip, branchruleptr, name, desc, priority, maxdepth, maxbounddist, branchruledata) - ccall((:SCIPincludeBranchruleBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BRANCHRULE}}, Cstring, Cstring, Cint, Cint, Cdouble, Ptr{SCIP_BRANCHRULEDATA}), scip, branchruleptr, name, desc, priority, maxdepth, maxbounddist, branchruledata) + ccall((:SCIPincludeBranchruleBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BRANCHRULE}}, Cstring, Cstring, Cint, Cint, Cdouble, Ptr{SCIP_BRANCHRULEDATA}), scip, branchruleptr, name, desc, priority, maxdepth, maxbounddist, branchruledata) end function SCIPsetBranchruleCopy(scip, branchrule, branchcopy) - ccall((:SCIPsetBranchruleCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchcopy) + ccall((:SCIPsetBranchruleCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchcopy) end function SCIPsetBranchruleFree(scip, branchrule, branchfree) - ccall((:SCIPsetBranchruleFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchfree) + ccall((:SCIPsetBranchruleFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchfree) end function SCIPsetBranchruleInit(scip, branchrule, branchinit) - ccall((:SCIPsetBranchruleInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinit) + ccall((:SCIPsetBranchruleInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinit) end function SCIPsetBranchruleExit(scip, branchrule, branchexit) - ccall((:SCIPsetBranchruleExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexit) + ccall((:SCIPsetBranchruleExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexit) end function SCIPsetBranchruleInitsol(scip, branchrule, branchinitsol) - ccall((:SCIPsetBranchruleInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinitsol) + ccall((:SCIPsetBranchruleInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinitsol) end function SCIPsetBranchruleExitsol(scip, branchrule, branchexitsol) - ccall((:SCIPsetBranchruleExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexitsol) + ccall((:SCIPsetBranchruleExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexitsol) end function SCIPsetBranchruleExecLp(scip, branchrule, branchexeclp) - ccall((:SCIPsetBranchruleExecLp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexeclp) + ccall((:SCIPsetBranchruleExecLp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexeclp) end function SCIPsetBranchruleExecExt(scip, branchrule, branchexecext) - ccall((:SCIPsetBranchruleExecExt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecext) + ccall((:SCIPsetBranchruleExecExt, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecext) end function SCIPsetBranchruleExecPs(scip, branchrule, branchexecps) - ccall((:SCIPsetBranchruleExecPs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecps) + ccall((:SCIPsetBranchruleExecPs, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecps) end function SCIPfindBranchrule(scip, name) - ccall((:SCIPfindBranchrule, libscip), Ptr{SCIP_BRANCHRULE}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindBranchrule, libscip), Ptr{SCIP_BRANCHRULE}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetBranchrules(scip) - ccall((:SCIPgetBranchrules, libscip), Ptr{Ptr{SCIP_BRANCHRULE}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetBranchrules, libscip), Ptr{Ptr{SCIP_BRANCHRULE}}, (Ptr{SCIP_},), scip) end function SCIPgetNBranchrules(scip) - ccall((:SCIPgetNBranchrules, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNBranchrules, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetBranchrulePriority(scip, branchrule, priority) - ccall((:SCIPsetBranchrulePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, priority) + ccall((:SCIPsetBranchrulePriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, priority) end function SCIPsetBranchruleMaxdepth(scip, branchrule, maxdepth) - ccall((:SCIPsetBranchruleMaxdepth, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, maxdepth) + ccall((:SCIPsetBranchruleMaxdepth, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, maxdepth) end function SCIPsetBranchruleMaxbounddist(scip, branchrule, maxbounddist) - ccall((:SCIPsetBranchruleMaxbounddist, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cdouble), scip, branchrule, maxbounddist) + ccall((:SCIPsetBranchruleMaxbounddist, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BRANCHRULE}, Cdouble), scip, branchrule, maxbounddist) end function SCIPgetLPBranchCands(scip, lpcands, lpcandssol, lpcandsfrac, nlpcands, npriolpcands, nfracimplvars) - ccall((:SCIPgetLPBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, lpcands, lpcandssol, lpcandsfrac, nlpcands, npriolpcands, nfracimplvars) + ccall((:SCIPgetLPBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, lpcands, lpcandssol, lpcandsfrac, nlpcands, npriolpcands, nfracimplvars) end function SCIPgetNLPBranchCands(scip) - ccall((:SCIPgetNLPBranchCands, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPBranchCands, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioLPBranchCands(scip) - ccall((:SCIPgetNPrioLPBranchCands, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioLPBranchCands, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetExternBranchCands(scip, externcands, externcandssol, externcandsscore, nexterncands, nprioexterncands, nprioexternbins, nprioexternints, nprioexternimpls) - ccall((:SCIPgetExternBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, externcands, externcandssol, externcandsscore, nexterncands, nprioexterncands, nprioexternbins, nprioexternints, nprioexternimpls) + ccall((:SCIPgetExternBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, externcands, externcandssol, externcandsscore, nexterncands, nprioexterncands, nprioexternbins, nprioexternints, nprioexternimpls) end function SCIPgetNExternBranchCands(scip) - ccall((:SCIPgetNExternBranchCands, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNExternBranchCands, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioExternBranchCands(scip) - ccall((:SCIPgetNPrioExternBranchCands, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioExternBranchCands, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioExternBranchBins(scip) - ccall((:SCIPgetNPrioExternBranchBins, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioExternBranchBins, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioExternBranchInts(scip) - ccall((:SCIPgetNPrioExternBranchInts, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioExternBranchInts, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioExternBranchImpls(scip) - ccall((:SCIPgetNPrioExternBranchImpls, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioExternBranchImpls, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioExternBranchConts(scip) - ccall((:SCIPgetNPrioExternBranchConts, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioExternBranchConts, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPaddExternBranchCand(scip, var, score, solval) - ccall((:SCIPaddExternBranchCand, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, score, solval) + ccall((:SCIPaddExternBranchCand, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, score, solval) end function SCIPclearExternBranchCands(scip) - ccall((:SCIPclearExternBranchCands, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPclearExternBranchCands, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPcontainsExternBranchCand(scip, var) - ccall((:SCIPcontainsExternBranchCand, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPcontainsExternBranchCand, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetPseudoBranchCands(scip, pseudocands, npseudocands, npriopseudocands) - ccall((:SCIPgetPseudoBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}), scip, pseudocands, npseudocands, npriopseudocands) + ccall((:SCIPgetPseudoBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}), scip, pseudocands, npseudocands, npriopseudocands) end function SCIPgetNPseudoBranchCands(scip) - ccall((:SCIPgetNPseudoBranchCands, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPseudoBranchCands, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioPseudoBranchCands(scip) - ccall((:SCIPgetNPrioPseudoBranchCands, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioPseudoBranchCands, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioPseudoBranchBins(scip) - ccall((:SCIPgetNPrioPseudoBranchBins, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioPseudoBranchBins, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioPseudoBranchInts(scip) - ccall((:SCIPgetNPrioPseudoBranchInts, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioPseudoBranchInts, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPrioPseudoBranchImpls(scip) - ccall((:SCIPgetNPrioPseudoBranchImpls, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrioPseudoBranchImpls, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetBranchScore(scip, var, downgain, upgain) - ccall((:SCIPgetBranchScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, downgain, upgain) + ccall((:SCIPgetBranchScore, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, downgain, upgain) end function SCIPgetBranchScoreMultiple(scip, var, nchildren, gains) - ccall((:SCIPgetBranchScoreMultiple, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, nchildren, gains) + ccall((:SCIPgetBranchScoreMultiple, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, nchildren, gains) end function SCIPgetBranchingPoint(scip, var, suggestion) - ccall((:SCIPgetBranchingPoint, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, suggestion) + ccall((:SCIPgetBranchingPoint, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, suggestion) end function SCIPcalcNodeselPriority(scip, var, branchdir, targetvalue) - ccall((:SCIPcalcNodeselPriority, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), scip, var, branchdir, targetvalue) + ccall((:SCIPcalcNodeselPriority, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), scip, var, branchdir, targetvalue) end function SCIPcalcChildEstimate(scip, var, targetvalue) - ccall((:SCIPcalcChildEstimate, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, targetvalue) + ccall((:SCIPcalcChildEstimate, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, targetvalue) end function SCIPcreateChild(scip, node, nodeselprio, estimate) - ccall((:SCIPcreateChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NODE}}, Cdouble, Cdouble), scip, node, nodeselprio, estimate) + ccall((:SCIPcreateChild, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_NODE}}, Cdouble, Cdouble), scip, node, nodeselprio, estimate) end function SCIPbranchVar(scip, var, downchild, eqchild, upchild) - ccall((:SCIPbranchVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, downchild, eqchild, upchild) + ccall((:SCIPbranchVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, downchild, eqchild, upchild) end function SCIPbranchVarHole(scip, var, left, right, downchild, upchild) - ccall((:SCIPbranchVarHole, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, left, right, downchild, upchild) + ccall((:SCIPbranchVarHole, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, left, right, downchild, upchild) end function SCIPbranchVarVal(scip, var, val, downchild, eqchild, upchild) - ccall((:SCIPbranchVarVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, val, downchild, eqchild, upchild) + ccall((:SCIPbranchVarVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, val, downchild, eqchild, upchild) end function SCIPbranchVarValNary(scip, var, val, n, minwidth, widthfactor, nchildren) - ccall((:SCIPbranchVarValNary, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cint, Cdouble, Cdouble, Ptr{Cint}), scip, var, val, n, minwidth, widthfactor, nchildren) + ccall((:SCIPbranchVarValNary, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cint, Cdouble, Cdouble, Ptr{Cint}), scip, var, val, n, minwidth, widthfactor, nchildren) end function SCIPbranchLP(scip, result) - ccall((:SCIPbranchLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) + ccall((:SCIPbranchLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RESULT}), scip, result) end function SCIPbranchExtern(scip, result) - ccall((:SCIPbranchExtern, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) + ccall((:SCIPbranchExtern, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RESULT}), scip, result) end function SCIPbranchPseudo(scip, result) - ccall((:SCIPbranchPseudo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) + ccall((:SCIPbranchPseudo, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RESULT}), scip, result) end diff --git a/src/wrapper/scip_compr.jl b/src/wrapper/scip_compr.jl index a0c7ce42..4498dfc3 100644 --- a/src/wrapper/scip_compr.jl +++ b/src/wrapper/scip_compr.jl @@ -3,49 +3,49 @@ function SCIPincludeCompr(scip, name, desc, priority, minnnodes, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) - ccall((:SCIPincludeCompr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, name, desc, priority, minnnodes, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) + ccall((:SCIPincludeCompr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, name, desc, priority, minnnodes, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) end function SCIPincludeComprBasic(scip, compr, name, desc, priority, minnnodes, comprexec, comprdata) - ccall((:SCIPincludeComprBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_COMPR}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, compr, name, desc, priority, minnnodes, comprexec, comprdata) + ccall((:SCIPincludeComprBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_COMPR}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, compr, name, desc, priority, minnnodes, comprexec, comprdata) end function SCIPsetComprCopy(scip, compr, comprcopy) - ccall((:SCIPsetComprCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprcopy) + ccall((:SCIPsetComprCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprcopy) end function SCIPsetComprFree(scip, compr, comprfree) - ccall((:SCIPsetComprFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprfree) + ccall((:SCIPsetComprFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprfree) end function SCIPsetComprInit(scip, compr, comprinit) - ccall((:SCIPsetComprInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinit) + ccall((:SCIPsetComprInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinit) end function SCIPsetComprExit(scip, compr, comprexit) - ccall((:SCIPsetComprExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexit) + ccall((:SCIPsetComprExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexit) end function SCIPsetComprInitsol(scip, compr, comprinitsol) - ccall((:SCIPsetComprInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinitsol) + ccall((:SCIPsetComprInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinitsol) end function SCIPsetComprExitsol(scip, compr, comprexitsol) - ccall((:SCIPsetComprExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexitsol) + ccall((:SCIPsetComprExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexitsol) end function SCIPfindCompr(scip, name) - ccall((:SCIPfindCompr, libscip), Ptr{SCIP_COMPR}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindCompr, libscip), Ptr{SCIP_COMPR}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetComprs(scip) - ccall((:SCIPgetComprs, libscip), Ptr{Ptr{SCIP_COMPR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetComprs, libscip), Ptr{Ptr{SCIP_COMPR}}, (Ptr{SCIP_},), scip) end function SCIPgetNCompr(scip) - ccall((:SCIPgetNCompr, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNCompr, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetComprPriority(scip, compr, priority) - ccall((:SCIPsetComprPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Cint), scip, compr, priority) + ccall((:SCIPsetComprPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_COMPR}, Cint), scip, compr, priority) end diff --git a/src/wrapper/scip_concurrent.jl b/src/wrapper/scip_concurrent.jl index adecb17a..5085788e 100644 --- a/src/wrapper/scip_concurrent.jl +++ b/src/wrapper/scip_concurrent.jl @@ -3,29 +3,29 @@ function SCIPincludeConcsolverType(scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) - ccall((:SCIPincludeConcsolverType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONCSOLVERTYPEDATA}), scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) + ccall((:SCIPincludeConcsolverType, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONCSOLVERTYPEDATA}), scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) end function SCIPfindConcsolverType(scip, name) - ccall((:SCIPfindConcsolverType, libscip), Ptr{SCIP_CONCSOLVERTYPE}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindConcsolverType, libscip), Ptr{SCIP_CONCSOLVERTYPE}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetConcsolverTypes(scip) - ccall((:SCIPgetConcsolverTypes, libscip), Ptr{Ptr{SCIP_CONCSOLVERTYPE}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetConcsolverTypes, libscip), Ptr{Ptr{SCIP_CONCSOLVERTYPE}}, (Ptr{SCIP_},), scip) end function SCIPgetNConcsolverTypes(scip) - ccall((:SCIPgetNConcsolverTypes, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNConcsolverTypes, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPconstructSyncstore(scip) - ccall((:SCIPconstructSyncstore, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPconstructSyncstore, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPfreeSyncstore(scip) - ccall((:SCIPfreeSyncstore, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPfreeSyncstore, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPgetSyncstore(scip) - ccall((:SCIPgetSyncstore, libscip), Ptr{SCIP_SYNCSTORE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetSyncstore, libscip), Ptr{SCIP_SYNCSTORE}, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_conflict.jl b/src/wrapper/scip_conflict.jl index ebcd0d2e..d8e7af67 100644 --- a/src/wrapper/scip_conflict.jl +++ b/src/wrapper/scip_conflict.jl @@ -3,105 +3,105 @@ function SCIPincludeConflicthdlr(scip, name, desc, priority, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) - ccall((:SCIPincludeConflicthdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, name, desc, priority, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) + ccall((:SCIPincludeConflicthdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, name, desc, priority, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) end function SCIPincludeConflicthdlrBasic(scip, conflicthdlrptr, name, desc, priority, conflictexec, conflicthdlrdata) - ccall((:SCIPincludeConflicthdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONFLICTHDLR}}, Cstring, Cstring, Cint, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, conflicthdlrptr, name, desc, priority, conflictexec, conflicthdlrdata) + ccall((:SCIPincludeConflicthdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONFLICTHDLR}}, Cstring, Cstring, Cint, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, conflicthdlrptr, name, desc, priority, conflictexec, conflicthdlrdata) end function SCIPsetConflicthdlrCopy(scip, conflicthdlr, conflictcopy) - ccall((:SCIPsetConflicthdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictcopy) + ccall((:SCIPsetConflicthdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictcopy) end function SCIPsetConflicthdlrFree(scip, conflicthdlr, conflictfree) - ccall((:SCIPsetConflicthdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictfree) + ccall((:SCIPsetConflicthdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictfree) end function SCIPsetConflicthdlrInit(scip, conflicthdlr, conflictinit) - ccall((:SCIPsetConflicthdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinit) + ccall((:SCIPsetConflicthdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinit) end function SCIPsetConflicthdlrExit(scip, conflicthdlr, conflictexit) - ccall((:SCIPsetConflicthdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexit) + ccall((:SCIPsetConflicthdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexit) end function SCIPsetConflicthdlrInitsol(scip, conflicthdlr, conflictinitsol) - ccall((:SCIPsetConflicthdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinitsol) + ccall((:SCIPsetConflicthdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinitsol) end function SCIPsetConflicthdlrExitsol(scip, conflicthdlr, conflictexitsol) - ccall((:SCIPsetConflicthdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexitsol) + ccall((:SCIPsetConflicthdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexitsol) end function SCIPfindConflicthdlr(scip, name) - ccall((:SCIPfindConflicthdlr, libscip), Ptr{SCIP_CONFLICTHDLR}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindConflicthdlr, libscip), Ptr{SCIP_CONFLICTHDLR}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetConflicthdlrs(scip) - ccall((:SCIPgetConflicthdlrs, libscip), Ptr{Ptr{SCIP_CONFLICTHDLR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetConflicthdlrs, libscip), Ptr{Ptr{SCIP_CONFLICTHDLR}}, (Ptr{SCIP_},), scip) end function SCIPgetNConflicthdlrs(scip) - ccall((:SCIPgetNConflicthdlrs, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNConflicthdlrs, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetConflicthdlrPriority(scip, conflicthdlr, priority) - ccall((:SCIPsetConflicthdlrPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Cint), scip, conflicthdlr, priority) + ccall((:SCIPsetConflicthdlrPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONFLICTHDLR}, Cint), scip, conflicthdlr, priority) end function SCIPisConflictAnalysisApplicable(scip) - ccall((:SCIPisConflictAnalysisApplicable, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisConflictAnalysisApplicable, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPinitConflictAnalysis(scip, conftype, iscutoffinvolved) - ccall((:SCIPinitConflictAnalysis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_CONFTYPE, UInt32), scip, conftype, iscutoffinvolved) + ccall((:SCIPinitConflictAnalysis, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_CONFTYPE, UInt32), scip, conftype, iscutoffinvolved) end function SCIPaddConflictLb(scip, var, bdchgidx) - ccall((:SCIPaddConflictLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) + ccall((:SCIPaddConflictLb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) end function SCIPaddConflictRelaxedLb(scip, var, bdchgidx, relaxedlb) - ccall((:SCIPaddConflictRelaxedLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedlb) + ccall((:SCIPaddConflictRelaxedLb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedlb) end function SCIPaddConflictUb(scip, var, bdchgidx) - ccall((:SCIPaddConflictUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) + ccall((:SCIPaddConflictUb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) end function SCIPaddConflictRelaxedUb(scip, var, bdchgidx, relaxedub) - ccall((:SCIPaddConflictRelaxedUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedub) + ccall((:SCIPaddConflictRelaxedUb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedub) end function SCIPaddConflictBd(scip, var, boundtype, bdchgidx) - ccall((:SCIPaddConflictBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}), scip, var, boundtype, bdchgidx) + ccall((:SCIPaddConflictBd, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}), scip, var, boundtype, bdchgidx) end function SCIPaddConflictRelaxedBd(scip, var, boundtype, bdchgidx, relaxedbd) - ccall((:SCIPaddConflictRelaxedBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, boundtype, bdchgidx, relaxedbd) + ccall((:SCIPaddConflictRelaxedBd, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, boundtype, bdchgidx, relaxedbd) end function SCIPaddConflictBinvar(scip, var) - ccall((:SCIPaddConflictBinvar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPaddConflictBinvar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPisConflictVarUsed(scip, var, boundtype, bdchgidx, used) - ccall((:SCIPisConflictVarUsed, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Ptr{UInt32}), scip, var, boundtype, bdchgidx, used) + ccall((:SCIPisConflictVarUsed, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Ptr{UInt32}), scip, var, boundtype, bdchgidx, used) end function SCIPgetConflictVarLb(scip, var) - ccall((:SCIPgetConflictVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetConflictVarLb, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetConflictVarUb(scip, var) - ccall((:SCIPgetConflictVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetConflictVarUb, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPanalyzeConflict(scip, validdepth, success) - ccall((:SCIPanalyzeConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}), scip, validdepth, success) + ccall((:SCIPanalyzeConflict, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{UInt32}), scip, validdepth, success) end function SCIPanalyzeConflictCons(scip, cons, success) - ccall((:SCIPanalyzeConflictCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{UInt32}), scip, cons, success) + ccall((:SCIPanalyzeConflictCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{UInt32}), scip, cons, success) end diff --git a/src/wrapper/scip_cons.jl b/src/wrapper/scip_cons.jl index 8b69a0ff..abedccb2 100644 --- a/src/wrapper/scip_cons.jl +++ b/src/wrapper/scip_cons.jl @@ -3,317 +3,317 @@ function SCIPincludeConshdlr(scip, name, desc, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol, consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, conshdlrdata) - ccall((:SCIPincludeConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cint, Cint, Cint, Cint, Cint, UInt32, UInt32, UInt32, SCIP_PROPTIMING, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONSHDLRDATA}), scip, name, desc, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol, consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, conshdlrdata) + ccall((:SCIPincludeConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Cint, Cint, Cint, Cint, Cint, Cint, UInt32, UInt32, UInt32, SCIP_PROPTIMING, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONSHDLRDATA}), scip, name, desc, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, conshdlrcopy, consfree, consinit, consexit, consinitpre, consexitpre, consinitsol, consexitsol, consdelete, constrans, consinitlp, conssepalp, conssepasol, consenfolp, consenforelax, consenfops, conscheck, consprop, conspresol, consresprop, conslock, consactive, consdeactive, consenable, consdisable, consdelvars, consprint, conscopy, consparse, consgetvars, consgetnvars, consgetdivebdchgs, conshdlrdata) end function SCIPincludeConshdlrBasic(scip, conshdlrptr, name, desc, enfopriority, chckpriority, eagerfreq, needscons, consenfolp, consenfops, conscheck, conslock, conshdlrdata) - ccall((:SCIPincludeConshdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONSHDLR}}, Cstring, Cstring, Cint, Cint, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONSHDLRDATA}), scip, conshdlrptr, name, desc, enfopriority, chckpriority, eagerfreq, needscons, consenfolp, consenfops, conscheck, conslock, conshdlrdata) + ccall((:SCIPincludeConshdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONSHDLR}}, Cstring, Cstring, Cint, Cint, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONSHDLRDATA}), scip, conshdlrptr, name, desc, enfopriority, chckpriority, eagerfreq, needscons, consenfolp, consenfops, conscheck, conslock, conshdlrdata) end function SCIPsetConshdlrSepa(scip, conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) - ccall((:SCIPsetConshdlrSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, UInt32), scip, conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) + ccall((:SCIPsetConshdlrSepa, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, UInt32), scip, conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) end function SCIPsetConshdlrProp(scip, conshdlr, consprop, propfreq, delayprop, proptiming) - ccall((:SCIPsetConshdlrProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, UInt32, SCIP_PROPTIMING), scip, conshdlr, consprop, propfreq, delayprop, proptiming) + ccall((:SCIPsetConshdlrProp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, UInt32, SCIP_PROPTIMING), scip, conshdlr, consprop, propfreq, delayprop, proptiming) end function SCIPsetConshdlrEnforelax(scip, conshdlr, consenforelax) - ccall((:SCIPsetConshdlrEnforelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenforelax) + ccall((:SCIPsetConshdlrEnforelax, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenforelax) end function SCIPsetConshdlrCopy(scip, conshdlr, conshdlrcopy, conscopy) - ccall((:SCIPsetConshdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, conshdlr, conshdlrcopy, conscopy) + ccall((:SCIPsetConshdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, conshdlr, conshdlrcopy, conscopy) end function SCIPsetConshdlrFree(scip, conshdlr, consfree) - ccall((:SCIPsetConshdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consfree) + ccall((:SCIPsetConshdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consfree) end function SCIPsetConshdlrInit(scip, conshdlr, consinit) - ccall((:SCIPsetConshdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinit) + ccall((:SCIPsetConshdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinit) end function SCIPsetConshdlrExit(scip, conshdlr, consexit) - ccall((:SCIPsetConshdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexit) + ccall((:SCIPsetConshdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexit) end function SCIPsetConshdlrInitsol(scip, conshdlr, consinitsol) - ccall((:SCIPsetConshdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitsol) + ccall((:SCIPsetConshdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitsol) end function SCIPsetConshdlrExitsol(scip, conshdlr, consexitsol) - ccall((:SCIPsetConshdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitsol) + ccall((:SCIPsetConshdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitsol) end function SCIPsetConshdlrInitpre(scip, conshdlr, consinitpre) - ccall((:SCIPsetConshdlrInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitpre) + ccall((:SCIPsetConshdlrInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitpre) end function SCIPsetConshdlrExitpre(scip, conshdlr, consexitpre) - ccall((:SCIPsetConshdlrExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitpre) + ccall((:SCIPsetConshdlrExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitpre) end function SCIPsetConshdlrPresol(scip, conshdlr, conspresol, maxprerounds, presoltiming) - ccall((:SCIPsetConshdlrPresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, SCIP_PRESOLTIMING), scip, conshdlr, conspresol, maxprerounds, presoltiming) + ccall((:SCIPsetConshdlrPresol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, SCIP_PRESOLTIMING), scip, conshdlr, conspresol, maxprerounds, presoltiming) end function SCIPsetConshdlrDelete(scip, conshdlr, consdelete) - ccall((:SCIPsetConshdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelete) + ccall((:SCIPsetConshdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelete) end function SCIPsetConshdlrTrans(scip, conshdlr, constrans) - ccall((:SCIPsetConshdlrTrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, constrans) + ccall((:SCIPsetConshdlrTrans, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, constrans) end function SCIPsetConshdlrInitlp(scip, conshdlr, consinitlp) - ccall((:SCIPsetConshdlrInitlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitlp) + ccall((:SCIPsetConshdlrInitlp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitlp) end function SCIPsetConshdlrResprop(scip, conshdlr, consresprop) - ccall((:SCIPsetConshdlrResprop, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consresprop) + ccall((:SCIPsetConshdlrResprop, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consresprop) end function SCIPsetConshdlrActive(scip, conshdlr, consactive) - ccall((:SCIPsetConshdlrActive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consactive) + ccall((:SCIPsetConshdlrActive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consactive) end function SCIPsetConshdlrDeactive(scip, conshdlr, consdeactive) - ccall((:SCIPsetConshdlrDeactive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdeactive) + ccall((:SCIPsetConshdlrDeactive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdeactive) end function SCIPsetConshdlrEnable(scip, conshdlr, consenable) - ccall((:SCIPsetConshdlrEnable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenable) + ccall((:SCIPsetConshdlrEnable, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenable) end function SCIPsetConshdlrDisable(scip, conshdlr, consdisable) - ccall((:SCIPsetConshdlrDisable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdisable) + ccall((:SCIPsetConshdlrDisable, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdisable) end function SCIPsetConshdlrDelvars(scip, conshdlr, consdelvars) - ccall((:SCIPsetConshdlrDelvars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelvars) + ccall((:SCIPsetConshdlrDelvars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelvars) end function SCIPsetConshdlrPrint(scip, conshdlr, consprint) - ccall((:SCIPsetConshdlrPrint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consprint) + ccall((:SCIPsetConshdlrPrint, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consprint) end function SCIPsetConshdlrParse(scip, conshdlr, consparse) - ccall((:SCIPsetConshdlrParse, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consparse) + ccall((:SCIPsetConshdlrParse, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consparse) end function SCIPsetConshdlrGetVars(scip, conshdlr, consgetvars) - ccall((:SCIPsetConshdlrGetVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetvars) + ccall((:SCIPsetConshdlrGetVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetvars) end function SCIPsetConshdlrGetNVars(scip, conshdlr, consgetnvars) - ccall((:SCIPsetConshdlrGetNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetnvars) + ccall((:SCIPsetConshdlrGetNVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetnvars) end function SCIPsetConshdlrGetDiveBdChgs(scip, conshdlr, consgetdivebdchgs) - ccall((:SCIPsetConshdlrGetDiveBdChgs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetdivebdchgs) + ccall((:SCIPsetConshdlrGetDiveBdChgs, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetdivebdchgs) end function SCIPfindConshdlr(scip, name) - ccall((:SCIPfindConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetConshdlrs(scip) - ccall((:SCIPgetConshdlrs, libscip), Ptr{Ptr{SCIP_CONSHDLR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetConshdlrs, libscip), Ptr{Ptr{SCIP_CONSHDLR}}, (Ptr{SCIP_},), scip) end function SCIPgetNConshdlrs(scip) - ccall((:SCIPgetNConshdlrs, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNConshdlrs, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPcreateCons(scip, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONSDATA}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONSDATA}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) end function SCIPparseCons(scip, cons, str, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, success) - ccall((:SCIPparseCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Cstring, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, cons, str, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, success) + ccall((:SCIPparseCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}, Cstring, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, cons, str, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, success) end function SCIPcaptureCons(scip, cons) - ccall((:SCIPcaptureCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPcaptureCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPreleaseCons(scip, cons) - ccall((:SCIPreleaseCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}), scip, cons) + ccall((:SCIPreleaseCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CONS}}), scip, cons) end function SCIPchgConsName(scip, cons, name) - ccall((:SCIPchgConsName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cstring), scip, cons, name) + ccall((:SCIPchgConsName, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cstring), scip, cons, name) end function SCIPsetConsInitial(scip, cons, initial) - ccall((:SCIPsetConsInitial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, initial) + ccall((:SCIPsetConsInitial, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, initial) end function SCIPsetConsSeparated(scip, cons, separate) - ccall((:SCIPsetConsSeparated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, separate) + ccall((:SCIPsetConsSeparated, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, separate) end function SCIPsetConsEnforced(scip, cons, enforce) - ccall((:SCIPsetConsEnforced, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, enforce) + ccall((:SCIPsetConsEnforced, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, enforce) end function SCIPsetConsChecked(scip, cons, check) - ccall((:SCIPsetConsChecked, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, check) + ccall((:SCIPsetConsChecked, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, check) end function SCIPsetConsPropagated(scip, cons, propagate) - ccall((:SCIPsetConsPropagated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, propagate) + ccall((:SCIPsetConsPropagated, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, propagate) end function SCIPsetConsLocal(scip, cons, _local) - ccall((:SCIPsetConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, _local) + ccall((:SCIPsetConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, _local) end function SCIPsetConsModifiable(scip, cons, modifiable) - ccall((:SCIPsetConsModifiable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, modifiable) + ccall((:SCIPsetConsModifiable, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, modifiable) end function SCIPsetConsDynamic(scip, cons, dynamic) - ccall((:SCIPsetConsDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, dynamic) + ccall((:SCIPsetConsDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, dynamic) end function SCIPsetConsRemovable(scip, cons, removable) - ccall((:SCIPsetConsRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, removable) + ccall((:SCIPsetConsRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, removable) end function SCIPsetConsStickingAtNode(scip, cons, stickingatnode) - ccall((:SCIPsetConsStickingAtNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32), scip, cons, stickingatnode) + ccall((:SCIPsetConsStickingAtNode, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32), scip, cons, stickingatnode) end function SCIPupdateConsFlags(scip, cons0, cons1) - ccall((:SCIPupdateConsFlags, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons0, cons1) + ccall((:SCIPupdateConsFlags, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons0, cons1) end function SCIPtransformCons(scip, cons, transcons) - ccall((:SCIPtransformCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) + ccall((:SCIPtransformCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) end function SCIPtransformConss(scip, nconss, conss, transconss) - ccall((:SCIPtransformConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) + ccall((:SCIPtransformConss, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) end function SCIPgetTransformedCons(scip, cons, transcons) - ccall((:SCIPgetTransformedCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) + ccall((:SCIPgetTransformedCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) end function SCIPgetTransformedConss(scip, nconss, conss, transconss) - ccall((:SCIPgetTransformedConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) + ccall((:SCIPgetTransformedConss, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) end function SCIPaddConsAge(scip, cons, deltaage) - ccall((:SCIPaddConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, deltaage) + ccall((:SCIPaddConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cdouble), scip, cons, deltaage) end function SCIPincConsAge(scip, cons) - ccall((:SCIPincConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPincConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPresetConsAge(scip, cons) - ccall((:SCIPresetConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPresetConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPenableCons(scip, cons) - ccall((:SCIPenableCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPenableCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdisableCons(scip, cons) - ccall((:SCIPdisableCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPdisableCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPenableConsSeparation(scip, cons) - ccall((:SCIPenableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPenableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdisableConsSeparation(scip, cons) - ccall((:SCIPdisableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPdisableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPenableConsPropagation(scip, cons) - ccall((:SCIPenableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPenableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdisableConsPropagation(scip, cons) - ccall((:SCIPdisableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPdisableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPmarkConsPropagate(scip, cons) - ccall((:SCIPmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPunmarkConsPropagate(scip, cons) - ccall((:SCIPunmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPunmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPaddConsLocksType(scip, cons, locktype, nlockspos, nlocksneg) - ccall((:SCIPaddConsLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_LOCKTYPE, Cint, Cint), scip, cons, locktype, nlockspos, nlocksneg) + ccall((:SCIPaddConsLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, SCIP_LOCKTYPE, Cint, Cint), scip, cons, locktype, nlockspos, nlocksneg) end function SCIPaddConsLocks(scip, cons, nlockspos, nlocksneg) - ccall((:SCIPaddConsLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cint, Cint), scip, cons, nlockspos, nlocksneg) + ccall((:SCIPaddConsLocks, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cint, Cint), scip, cons, nlockspos, nlocksneg) end function SCIPcheckCons(scip, cons, sol, checkintegrality, checklprows, printreason, result) - ccall((:SCIPcheckCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, Ptr{SCIP_RESULT}), scip, cons, sol, checkintegrality, checklprows, printreason, result) + ccall((:SCIPcheckCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, Ptr{SCIP_RESULT}), scip, cons, sol, checkintegrality, checklprows, printreason, result) end function SCIPenfopsCons(scip, cons, solinfeasible, objinfeasible, result) - ccall((:SCIPenfopsCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32, UInt32, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, objinfeasible, result) + ccall((:SCIPenfopsCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32, UInt32, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, objinfeasible, result) end function SCIPenfolpCons(scip, cons, solinfeasible, result) - ccall((:SCIPenfolpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, UInt32, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, result) + ccall((:SCIPenfolpCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, UInt32, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, result) end function SCIPenforelaxCons(scip, cons, sol, solinfeasible, result) - ccall((:SCIPenforelaxCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, UInt32, Ptr{SCIP_RESULT}), scip, cons, sol, solinfeasible, result) + ccall((:SCIPenforelaxCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, UInt32, Ptr{SCIP_RESULT}), scip, cons, sol, solinfeasible, result) end function SCIPinitlpCons(scip, cons, infeasible) - ccall((:SCIPinitlpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{UInt32}), scip, cons, infeasible) + ccall((:SCIPinitlpCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{UInt32}), scip, cons, infeasible) end function SCIPsepalpCons(scip, cons, result) - ccall((:SCIPsepalpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RESULT}), scip, cons, result) + ccall((:SCIPsepalpCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_RESULT}), scip, cons, result) end function SCIPsepasolCons(scip, cons, sol, result) - ccall((:SCIPsepasolCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cons, sol, result) + ccall((:SCIPsepasolCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cons, sol, result) end function SCIPpropCons(scip, cons, proptiming, result) - ccall((:SCIPpropCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_PROPTIMING, Ptr{SCIP_RESULT}), scip, cons, proptiming, result) + ccall((:SCIPpropCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, SCIP_PROPTIMING, Ptr{SCIP_RESULT}), scip, cons, proptiming, result) end function SCIPrespropCons(scip, cons, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, result) - ccall((:SCIPrespropCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cint, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble, Ptr{SCIP_RESULT}), scip, cons, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, result) + ccall((:SCIPrespropCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cint, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble, Ptr{SCIP_RESULT}), scip, cons, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, result) end function SCIPpresolCons(scip, cons, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) - ccall((:SCIPpresolCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cint, SCIP_PRESOLTIMING, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{SCIP_RESULT}), scip, cons, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) + ccall((:SCIPpresolCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Cint, SCIP_PRESOLTIMING, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{SCIP_RESULT}), scip, cons, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes, ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) end function SCIPactiveCons(scip, cons) - ccall((:SCIPactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdeactiveCons(scip, cons) - ccall((:SCIPdeactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPdeactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPprintCons(scip, cons, file) - ccall((:SCIPprintCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{FILE}), scip, cons, file) + ccall((:SCIPprintCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{FILE}), scip, cons, file) end function SCIPgetConsVars(scip, cons, vars, varssize, success) - ccall((:SCIPgetConsVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{UInt32}), scip, cons, vars, varssize, success) + ccall((:SCIPgetConsVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{UInt32}), scip, cons, vars, varssize, success) end function SCIPgetConsNVars(scip, cons, nvars, success) - ccall((:SCIPgetConsNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cint}, Ptr{UInt32}), scip, cons, nvars, success) + ccall((:SCIPgetConsNVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Cint}, Ptr{UInt32}), scip, cons, nvars, success) end diff --git a/src/wrapper/scip_copy.jl b/src/wrapper/scip_copy.jl index c62c85a5..f14710a0 100644 --- a/src/wrapper/scip_copy.jl +++ b/src/wrapper/scip_copy.jl @@ -3,105 +3,105 @@ function SCIPcopyPlugins(sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copydisplays, copydialogs, copytables, copynlpis, passmessagehdlr, valid) - ccall((:SCIPcopyPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copydisplays, copydialogs, copytables, copynlpis, passmessagehdlr, valid) + ccall((:SCIPcopyPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copydisplays, copydialogs, copytables, copynlpis, passmessagehdlr, valid) end function SCIPcopyBenders(sourcescip, targetscip, varmap, valid) - ccall((:SCIPcopyBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{UInt32}), sourcescip, targetscip, varmap, valid) + ccall((:SCIPcopyBenders, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{UInt32}), sourcescip, targetscip, varmap, valid) end function SCIPcopyProb(sourcescip, targetscip, varmap, consmap, _global, name) - ccall((:SCIPcopyProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Cstring), sourcescip, targetscip, varmap, consmap, _global, name) + ccall((:SCIPcopyProb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Cstring), sourcescip, targetscip, varmap, consmap, _global, name) end function SCIPcopyOrigProb(sourcescip, targetscip, varmap, consmap, name) - ccall((:SCIPcopyOrigProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring), sourcescip, targetscip, varmap, consmap, name) + ccall((:SCIPcopyOrigProb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring), sourcescip, targetscip, varmap, consmap, name) end function SCIPenableConsCompression(scip) - ccall((:SCIPenableConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPenableConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPisConsCompressionEnabled(scip) - ccall((:SCIPisConsCompressionEnabled, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisConsCompressionEnabled, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetVarCopy(sourcescip, targetscip, sourcevar, targetvar, varmap, consmap, _global, success) - ccall((:SCIPgetVarCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}), sourcescip, targetscip, sourcevar, targetvar, varmap, consmap, _global, success) + ccall((:SCIPgetVarCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}), sourcescip, targetscip, sourcevar, targetvar, varmap, consmap, _global, success) end function SCIPcopyVars(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars, _global) - ccall((:SCIPcopyVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars, _global) + ccall((:SCIPcopyVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars, _global) end function SCIPcopyOrigVars(sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars) - ccall((:SCIPcopyOrigVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars) + ccall((:SCIPcopyOrigVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), sourcescip, targetscip, varmap, consmap, fixedvars, fixedvals, nfixedvars) end function SCIPmergeVariableStatistics(sourcescip, targetscip, sourcevars, targetvars, nvars) - ccall((:SCIPmergeVariableStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint), sourcescip, targetscip, sourcevars, targetvars, nvars) + ccall((:SCIPmergeVariableStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint), sourcescip, targetscip, sourcevars, targetvars, nvars) end function SCIPgetConsCopy(sourcescip, targetscip, sourcecons, targetcons, sourceconshdlr, varmap, consmap, name, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) - ccall((:SCIPgetConsCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, sourcecons, targetcons, sourceconshdlr, varmap, consmap, name, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) + ccall((:SCIPgetConsCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, sourcecons, targetcons, sourceconshdlr, varmap, consmap, name, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) end function SCIPcopyConss(sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) - ccall((:SCIPcopyConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) + ccall((:SCIPcopyConss, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) end function SCIPcopyOrigConss(sourcescip, targetscip, varmap, consmap, enablepricing, valid) - ccall((:SCIPcopyOrigConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, enablepricing, valid) + ccall((:SCIPcopyOrigConss, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, enablepricing, valid) end function SCIPconvertCutsToConss(scip, varmap, consmap, _global, ncutsadded) - ccall((:SCIPconvertCutsToConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{Cint}), scip, varmap, consmap, _global, ncutsadded) + ccall((:SCIPconvertCutsToConss, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{Cint}), scip, varmap, consmap, _global, ncutsadded) end function SCIPcopyCuts(sourcescip, targetscip, varmap, consmap, _global, ncutsadded) - ccall((:SCIPcopyCuts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, ncutsadded) + ccall((:SCIPcopyCuts, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, ncutsadded) end function SCIPcopyConflicts(sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) - ccall((:SCIPcopyConflicts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) + ccall((:SCIPcopyConflicts, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, _global, enablepricing, valid) end function SCIPcopyImplicationsCliques(sourcescip, targetscip, varmap, consmap, _global, infeasible, nbdchgs, ncopied) - ccall((:SCIPcopyImplicationsCliques, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}, Ptr{Cint}, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, infeasible, nbdchgs, ncopied) + ccall((:SCIPcopyImplicationsCliques, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, UInt32, Ptr{UInt32}, Ptr{Cint}, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, infeasible, nbdchgs, ncopied) end function SCIPcopyParamSettings(sourcescip, targetscip) - ccall((:SCIPcopyParamSettings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}), sourcescip, targetscip) + ccall((:SCIPcopyParamSettings, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}), sourcescip, targetscip) end function SCIPgetSubscipDepth(scip) - ccall((:SCIPgetSubscipDepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetSubscipDepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetSubscipDepth(scip, newdepth) - ccall((:SCIPsetSubscipDepth, libscip), Cvoid, (Ptr{SCIP}, Cint), scip, newdepth) + ccall((:SCIPsetSubscipDepth, libscip), Cvoid, (Ptr{SCIP_}, Cint), scip, newdepth) end function SCIPcopy(sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, passmessagehdlr, valid) - ccall((:SCIPcopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, passmessagehdlr, valid) + ccall((:SCIPcopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, passmessagehdlr, valid) end function SCIPcopyConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, passmessagehdlr, valid) - ccall((:SCIPcopyConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, passmessagehdlr, valid) + ccall((:SCIPcopyConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, passmessagehdlr, valid) end function SCIPcopyOrig(sourcescip, targetscip, varmap, consmap, suffix, enablepricing, passmessagehdlr, valid) - ccall((:SCIPcopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, enablepricing, passmessagehdlr, valid) + ccall((:SCIPcopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, enablepricing, passmessagehdlr, valid) end function SCIPcopyOrigConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, passmessagehdlr, valid) - ccall((:SCIPcopyOrigConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, passmessagehdlr, valid) + ccall((:SCIPcopyOrigConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32, UInt32, Ptr{UInt32}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, passmessagehdlr, valid) end function SCIPcheckCopyLimits(sourcescip, success) - ccall((:SCIPcheckCopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), sourcescip, success) + ccall((:SCIPcheckCopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{UInt32}), sourcescip, success) end function SCIPcopyLimits(sourcescip, targetscip) - ccall((:SCIPcopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}), sourcescip, targetscip) + ccall((:SCIPcopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_}), sourcescip, targetscip) end diff --git a/src/wrapper/scip_cut.jl b/src/wrapper/scip_cut.jl index b910c1cd..584d3870 100644 --- a/src/wrapper/scip_cut.jl +++ b/src/wrapper/scip_cut.jl @@ -3,121 +3,121 @@ function SCIPgetCutEfficacy(scip, sol, cut) - ccall((:SCIPgetCutEfficacy, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) + ccall((:SCIPgetCutEfficacy, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) end function SCIPisCutEfficacious(scip, sol, cut) - ccall((:SCIPisCutEfficacious, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) + ccall((:SCIPisCutEfficacious, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) end function SCIPisEfficacious(scip, efficacy) - ccall((:SCIPisEfficacious, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, efficacy) + ccall((:SCIPisEfficacious, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, efficacy) end function SCIPgetVectorEfficacyNorm(scip, vals, nvals) - ccall((:SCIPgetVectorEfficacyNorm, libscip), Cdouble, (Ptr{SCIP}, Ptr{Cdouble}, Cint), scip, vals, nvals) + ccall((:SCIPgetVectorEfficacyNorm, libscip), Cdouble, (Ptr{SCIP_}, Ptr{Cdouble}, Cint), scip, vals, nvals) end function SCIPisCutApplicable(scip, cut) - ccall((:SCIPisCutApplicable, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, cut) + ccall((:SCIPisCutApplicable, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, cut) end function SCIPaddCut(scip, sol, cut, forcecut, infeasible) - ccall((:SCIPaddCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}, UInt32, Ptr{UInt32}), scip, sol, cut, forcecut, infeasible) + ccall((:SCIPaddCut, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}, UInt32, Ptr{UInt32}), scip, sol, cut, forcecut, infeasible) end function SCIPaddRow(scip, row, forcecut, infeasible) - ccall((:SCIPaddRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, UInt32, Ptr{UInt32}), scip, row, forcecut, infeasible) + ccall((:SCIPaddRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, UInt32, Ptr{UInt32}), scip, row, forcecut, infeasible) end function SCIPisCutNew(scip, row) - ccall((:SCIPisCutNew, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPisCutNew, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPaddPoolCut(scip, row) - ccall((:SCIPaddPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPaddPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPdelPoolCut(scip, row) - ccall((:SCIPdelPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPdelPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetPoolCuts(scip) - ccall((:SCIPgetPoolCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetPoolCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP_},), scip) end function SCIPgetNPoolCuts(scip) - ccall((:SCIPgetNPoolCuts, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPoolCuts, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetGlobalCutpool(scip) - ccall((:SCIPgetGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP},), scip) + ccall((:SCIPgetGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP_},), scip) end function SCIPcreateCutpool(scip, cutpool, agelimit) - ccall((:SCIPcreateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}, Cint), scip, cutpool, agelimit) + ccall((:SCIPcreateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CUTPOOL}}, Cint), scip, cutpool, agelimit) end function SCIPfreeCutpool(scip, cutpool) - ccall((:SCIPfreeCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}), scip, cutpool) + ccall((:SCIPfreeCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CUTPOOL}}), scip, cutpool) end function SCIPaddRowCutpool(scip, cutpool, row) - ccall((:SCIPaddRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) + ccall((:SCIPaddRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) end function SCIPaddNewRowCutpool(scip, cutpool, row) - ccall((:SCIPaddNewRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) + ccall((:SCIPaddNewRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) end function SCIPdelRowCutpool(scip, cutpool, row) - ccall((:SCIPdelRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) + ccall((:SCIPdelRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) end function SCIPseparateCutpool(scip, cutpool, result) - ccall((:SCIPseparateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_RESULT}), scip, cutpool, result) + ccall((:SCIPseparateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_RESULT}), scip, cutpool, result) end function SCIPseparateSolCutpool(scip, cutpool, sol, result) - ccall((:SCIPseparateSolCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cutpool, sol, result) + ccall((:SCIPseparateSolCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cutpool, sol, result) end function SCIPaddDelayedPoolCut(scip, row) - ccall((:SCIPaddDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPaddDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPdelDelayedPoolCut(scip, row) - ccall((:SCIPdelDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPdelDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetDelayedPoolCuts(scip) - ccall((:SCIPgetDelayedPoolCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetDelayedPoolCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP_},), scip) end function SCIPgetNDelayedPoolCuts(scip) - ccall((:SCIPgetNDelayedPoolCuts, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDelayedPoolCuts, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetDelayedGlobalCutpool(scip) - ccall((:SCIPgetDelayedGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP},), scip) + ccall((:SCIPgetDelayedGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP_},), scip) end function SCIPseparateSol(scip, sol, pretendroot, allowlocal, onlydelayed, delayed, cutoff) - ccall((:SCIPseparateSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, sol, pretendroot, allowlocal, onlydelayed, delayed, cutoff) + ccall((:SCIPseparateSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, sol, pretendroot, allowlocal, onlydelayed, delayed, cutoff) end function SCIPgetCuts(scip) - ccall((:SCIPgetCuts, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetCuts, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP_},), scip) end function SCIPgetNCuts(scip) - ccall((:SCIPgetNCuts, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNCuts, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPclearCuts(scip) - ccall((:SCIPclearCuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPclearCuts, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPremoveInefficaciousCuts(scip) - ccall((:SCIPremoveInefficaciousCuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPremoveInefficaciousCuts, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_datastructures.jl b/src/wrapper/scip_datastructures.jl index ce451ee7..ed143141 100644 --- a/src/wrapper/scip_datastructures.jl +++ b/src/wrapper/scip_datastructures.jl @@ -3,153 +3,153 @@ function SCIPcreateRealarray(scip, realarray) - ccall((:SCIPcreateRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) + ccall((:SCIPcreateRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) end function SCIPfreeRealarray(scip, realarray) - ccall((:SCIPfreeRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) + ccall((:SCIPfreeRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) end function SCIPextendRealarray(scip, realarray, minidx, maxidx) - ccall((:SCIPextendRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cint), scip, realarray, minidx, maxidx) + ccall((:SCIPextendRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_REALARRAY}, Cint, Cint), scip, realarray, minidx, maxidx) end function SCIPclearRealarray(scip, realarray) - ccall((:SCIPclearRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) + ccall((:SCIPclearRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_REALARRAY}), scip, realarray) end function SCIPgetRealarrayVal(scip, realarray, idx) - ccall((:SCIPgetRealarrayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint), scip, realarray, idx) + ccall((:SCIPgetRealarrayVal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_REALARRAY}, Cint), scip, realarray, idx) end function SCIPsetRealarrayVal(scip, realarray, idx, val) - ccall((:SCIPsetRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, val) + ccall((:SCIPsetRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, val) end function SCIPincRealarrayVal(scip, realarray, idx, incval) - ccall((:SCIPincRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, incval) + ccall((:SCIPincRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, incval) end function SCIPgetRealarrayMinIdx(scip, realarray) - ccall((:SCIPgetRealarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) + ccall((:SCIPgetRealarrayMinIdx, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_REALARRAY}), scip, realarray) end function SCIPgetRealarrayMaxIdx(scip, realarray) - ccall((:SCIPgetRealarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) + ccall((:SCIPgetRealarrayMaxIdx, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_REALARRAY}), scip, realarray) end function SCIPcreateIntarray(scip, intarray) - ccall((:SCIPcreateIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) + ccall((:SCIPcreateIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) end function SCIPfreeIntarray(scip, intarray) - ccall((:SCIPfreeIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) + ccall((:SCIPfreeIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) end function SCIPextendIntarray(scip, intarray, minidx, maxidx) - ccall((:SCIPextendIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, minidx, maxidx) + ccall((:SCIPextendIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, minidx, maxidx) end function SCIPclearIntarray(scip, intarray) - ccall((:SCIPclearIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) + ccall((:SCIPclearIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_INTARRAY}), scip, intarray) end function SCIPgetIntarrayVal(scip, intarray, idx) - ccall((:SCIPgetIntarrayVal, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint), scip, intarray, idx) + ccall((:SCIPgetIntarrayVal, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_INTARRAY}, Cint), scip, intarray, idx) end function SCIPsetIntarrayVal(scip, intarray, idx, val) - ccall((:SCIPsetIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, val) + ccall((:SCIPsetIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, val) end function SCIPincIntarrayVal(scip, intarray, idx, incval) - ccall((:SCIPincIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, incval) + ccall((:SCIPincIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, incval) end function SCIPgetIntarrayMinIdx(scip, intarray) - ccall((:SCIPgetIntarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) + ccall((:SCIPgetIntarrayMinIdx, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_INTARRAY}), scip, intarray) end function SCIPgetIntarrayMaxIdx(scip, intarray) - ccall((:SCIPgetIntarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) + ccall((:SCIPgetIntarrayMaxIdx, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_INTARRAY}), scip, intarray) end function SCIPcreateBoolarray(scip, boolarray) - ccall((:SCIPcreateBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) + ccall((:SCIPcreateBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) end function SCIPfreeBoolarray(scip, boolarray) - ccall((:SCIPfreeBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) + ccall((:SCIPfreeBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) end function SCIPextendBoolarray(scip, boolarray, minidx, maxidx) - ccall((:SCIPextendBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cint), scip, boolarray, minidx, maxidx) + ccall((:SCIPextendBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BOOLARRAY}, Cint, Cint), scip, boolarray, minidx, maxidx) end function SCIPclearBoolarray(scip, boolarray) - ccall((:SCIPclearBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) + ccall((:SCIPclearBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) end function SCIPgetBoolarrayVal(scip, boolarray, idx) - ccall((:SCIPgetBoolarrayVal, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint), scip, boolarray, idx) + ccall((:SCIPgetBoolarrayVal, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_BOOLARRAY}, Cint), scip, boolarray, idx) end function SCIPsetBoolarrayVal(scip, boolarray, idx, val) - ccall((:SCIPsetBoolarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, UInt32), scip, boolarray, idx, val) + ccall((:SCIPsetBoolarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BOOLARRAY}, Cint, UInt32), scip, boolarray, idx, val) end function SCIPgetBoolarrayMinIdx(scip, boolarray) - ccall((:SCIPgetBoolarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) + ccall((:SCIPgetBoolarrayMinIdx, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) end function SCIPgetBoolarrayMaxIdx(scip, boolarray) - ccall((:SCIPgetBoolarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) + ccall((:SCIPgetBoolarrayMaxIdx, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) end function SCIPcreatePtrarray(scip, ptrarray) - ccall((:SCIPcreatePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) + ccall((:SCIPcreatePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) end function SCIPfreePtrarray(scip, ptrarray) - ccall((:SCIPfreePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) + ccall((:SCIPfreePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) end function SCIPextendPtrarray(scip, ptrarray, minidx, maxidx) - ccall((:SCIPextendPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Cint), scip, ptrarray, minidx, maxidx) + ccall((:SCIPextendPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PTRARRAY}, Cint, Cint), scip, ptrarray, minidx, maxidx) end function SCIPclearPtrarray(scip, ptrarray) - ccall((:SCIPclearPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) + ccall((:SCIPclearPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) end function SCIPgetPtrarrayVal(scip, ptrarray, idx) - ccall((:SCIPgetPtrarrayVal, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint), scip, ptrarray, idx) + ccall((:SCIPgetPtrarrayVal, libscip), Ptr{Cvoid}, (Ptr{SCIP_}, Ptr{SCIP_PTRARRAY}, Cint), scip, ptrarray, idx) end function SCIPsetPtrarrayVal(scip, ptrarray, idx, val) - ccall((:SCIPsetPtrarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Ptr{Cvoid}), scip, ptrarray, idx, val) + ccall((:SCIPsetPtrarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PTRARRAY}, Cint, Ptr{Cvoid}), scip, ptrarray, idx, val) end function SCIPgetPtrarrayMinIdx(scip, ptrarray) - ccall((:SCIPgetPtrarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) + ccall((:SCIPgetPtrarrayMinIdx, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) end function SCIPgetPtrarrayMaxIdx(scip, ptrarray) - ccall((:SCIPgetPtrarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) + ccall((:SCIPgetPtrarrayMaxIdx, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) end function SCIPcreateDisjointset(scip, djset, ncomponents) - ccall((:SCIPcreateDisjointset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}, Cint), scip, djset, ncomponents) + ccall((:SCIPcreateDisjointset, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_DISJOINTSET}}, Cint), scip, djset, ncomponents) end function SCIPfreeDisjointset(scip, djset) - ccall((:SCIPfreeDisjointset, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}), scip, djset) + ccall((:SCIPfreeDisjointset, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Ptr{SCIP_DISJOINTSET}}), scip, djset) end function SCIPcreateDigraph(scip, digraph, nnodes) - ccall((:SCIPcreateDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Cint), scip, digraph, nnodes) + ccall((:SCIPcreateDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_DIGRAPH}}, Cint), scip, digraph, nnodes) end function SCIPcopyDigraph(scip, targetdigraph, sourcedigraph) - ccall((:SCIPcopyDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Ptr{SCIP_DIGRAPH}), scip, targetdigraph, sourcedigraph) + ccall((:SCIPcopyDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_DIGRAPH}}, Ptr{SCIP_DIGRAPH}), scip, targetdigraph, sourcedigraph) end diff --git a/src/wrapper/scip_debug.jl b/src/wrapper/scip_debug.jl index 7e4caa74..721472f0 100644 --- a/src/wrapper/scip_debug.jl +++ b/src/wrapper/scip_debug.jl @@ -3,9 +3,9 @@ function SCIPenableDebugSol(scip) - ccall((:SCIPenableDebugSol, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPenableDebugSol, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPdisableDebugSol(scip) - ccall((:SCIPdisableDebugSol, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPdisableDebugSol, libscip), Cvoid, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_dialog.jl b/src/wrapper/scip_dialog.jl index 351b62dc..159f6e54 100644 --- a/src/wrapper/scip_dialog.jl +++ b/src/wrapper/scip_dialog.jl @@ -3,41 +3,41 @@ function SCIPincludeDialog(scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu, dialogdata) - ccall((:SCIPincludeDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cstring, Cstring, UInt32, Ptr{SCIP_DIALOGDATA}), scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu, dialogdata) + ccall((:SCIPincludeDialog, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_DIALOG}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cstring, Cstring, UInt32, Ptr{SCIP_DIALOGDATA}), scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu, dialogdata) end function SCIPexistsDialog(scip, dialog) - ccall((:SCIPexistsDialog, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) + ccall((:SCIPexistsDialog, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_DIALOG}), scip, dialog) end function SCIPcaptureDialog(scip, dialog) - ccall((:SCIPcaptureDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) + ccall((:SCIPcaptureDialog, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIALOG}), scip, dialog) end function SCIPreleaseDialog(scip, dialog) - ccall((:SCIPreleaseDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog) + ccall((:SCIPreleaseDialog, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog) end function SCIPsetRootDialog(scip, dialog) - ccall((:SCIPsetRootDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) + ccall((:SCIPsetRootDialog, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIALOG}), scip, dialog) end function SCIPgetRootDialog(scip) - ccall((:SCIPgetRootDialog, libscip), Ptr{SCIP_DIALOG}, (Ptr{SCIP},), scip) + ccall((:SCIPgetRootDialog, libscip), Ptr{SCIP_DIALOG}, (Ptr{SCIP_},), scip) end function SCIPaddDialogEntry(scip, dialog, subdialog) - ccall((:SCIPaddDialogEntry, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOG}), scip, dialog, subdialog) + ccall((:SCIPaddDialogEntry, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOG}), scip, dialog, subdialog) end function SCIPaddDialogInputLine(scip, inputline) - ccall((:SCIPaddDialogInputLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, inputline) + ccall((:SCIPaddDialogInputLine, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, inputline) end function SCIPaddDialogHistoryLine(scip, inputline) - ccall((:SCIPaddDialogHistoryLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, inputline) + ccall((:SCIPaddDialogHistoryLine, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, inputline) end function SCIPstartInteraction(scip) - ccall((:SCIPstartInteraction, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPstartInteraction, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_disp.jl b/src/wrapper/scip_disp.jl index f7b1a2f2..a1cd1bd8 100644 --- a/src/wrapper/scip_disp.jl +++ b/src/wrapper/scip_disp.jl @@ -3,23 +3,23 @@ function SCIPincludeDisp(scip, name, desc, header, dispstatus, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width, priority, position, stripline) - ccall((:SCIPincludeDisp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cstring, SCIP_DISPSTATUS, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_DISPDATA}, Cint, Cint, Cint, UInt32), scip, name, desc, header, dispstatus, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width, priority, position, stripline) + ccall((:SCIPincludeDisp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cstring, SCIP_DISPSTATUS, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_DISPDATA}, Cint, Cint, Cint, UInt32), scip, name, desc, header, dispstatus, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width, priority, position, stripline) end function SCIPfindDisp(scip, name) - ccall((:SCIPfindDisp, libscip), Ptr{SCIP_DISP}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindDisp, libscip), Ptr{SCIP_DISP}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetDisps(scip) - ccall((:SCIPgetDisps, libscip), Ptr{Ptr{SCIP_DISP}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetDisps, libscip), Ptr{Ptr{SCIP_DISP}}, (Ptr{SCIP_},), scip) end function SCIPgetNDisps(scip) - ccall((:SCIPgetNDisps, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDisps, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPautoselectDisps(scip) - ccall((:SCIPautoselectDisps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPautoselectDisps, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPchgDispMode(disp, mode) diff --git a/src/wrapper/scip_event.jl b/src/wrapper/scip_event.jl index 97d0877a..459973df 100644 --- a/src/wrapper/scip_event.jl +++ b/src/wrapper/scip_event.jl @@ -3,73 +3,73 @@ function SCIPincludeEventhdlr(scip, name, desc, eventcopy, eventfree, eventinit, eventexit, eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata) - ccall((:SCIPincludeEventhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_EVENTHDLRDATA}), scip, name, desc, eventcopy, eventfree, eventinit, eventexit, eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata) + ccall((:SCIPincludeEventhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_EVENTHDLRDATA}), scip, name, desc, eventcopy, eventfree, eventinit, eventexit, eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata) end function SCIPincludeEventhdlrBasic(scip, eventhdlrptr, name, desc, eventexec, eventhdlrdata) - ccall((:SCIPincludeEventhdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EVENTHDLR}}, Cstring, Cstring, Ptr{Cvoid}, Ptr{SCIP_EVENTHDLRDATA}), scip, eventhdlrptr, name, desc, eventexec, eventhdlrdata) + ccall((:SCIPincludeEventhdlrBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_EVENTHDLR}}, Cstring, Cstring, Ptr{Cvoid}, Ptr{SCIP_EVENTHDLRDATA}), scip, eventhdlrptr, name, desc, eventexec, eventhdlrdata) end function SCIPsetEventhdlrCopy(scip, eventhdlr, eventcopy) - ccall((:SCIPsetEventhdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventcopy) + ccall((:SCIPsetEventhdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventcopy) end function SCIPsetEventhdlrFree(scip, eventhdlr, eventfree) - ccall((:SCIPsetEventhdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventfree) + ccall((:SCIPsetEventhdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventfree) end function SCIPsetEventhdlrInit(scip, eventhdlr, eventinit) - ccall((:SCIPsetEventhdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinit) + ccall((:SCIPsetEventhdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinit) end function SCIPsetEventhdlrExit(scip, eventhdlr, eventexit) - ccall((:SCIPsetEventhdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexit) + ccall((:SCIPsetEventhdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexit) end function SCIPsetEventhdlrInitsol(scip, eventhdlr, eventinitsol) - ccall((:SCIPsetEventhdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinitsol) + ccall((:SCIPsetEventhdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinitsol) end function SCIPsetEventhdlrExitsol(scip, eventhdlr, eventexitsol) - ccall((:SCIPsetEventhdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexitsol) + ccall((:SCIPsetEventhdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexitsol) end function SCIPsetEventhdlrDelete(scip, eventhdlr, eventdelete) - ccall((:SCIPsetEventhdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventdelete) + ccall((:SCIPsetEventhdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventdelete) end function SCIPfindEventhdlr(scip, name) - ccall((:SCIPfindEventhdlr, libscip), Ptr{SCIP_EVENTHDLR}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindEventhdlr, libscip), Ptr{SCIP_EVENTHDLR}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetEventhdlrs(scip) - ccall((:SCIPgetEventhdlrs, libscip), Ptr{Ptr{SCIP_EVENTHDLR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetEventhdlrs, libscip), Ptr{Ptr{SCIP_EVENTHDLR}}, (Ptr{SCIP_},), scip) end function SCIPgetNEventhdlrs(scip) - ccall((:SCIPgetNEventhdlrs, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNEventhdlrs, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPcatchEvent(scip, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPcatchEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, eventtype, eventhdlr, eventdata, filterpos) + ccall((:SCIPcatchEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, eventtype, eventhdlr, eventdata, filterpos) end function SCIPdropEvent(scip, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPdropEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, eventtype, eventhdlr, eventdata, filterpos) + ccall((:SCIPdropEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, eventtype, eventhdlr, eventdata, filterpos) end function SCIPcatchVarEvent(scip, var, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPcatchVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, var, eventtype, eventhdlr, eventdata, filterpos) + ccall((:SCIPcatchVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, var, eventtype, eventhdlr, eventdata, filterpos) end function SCIPdropVarEvent(scip, var, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPdropVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, var, eventtype, eventhdlr, eventdata, filterpos) + ccall((:SCIPdropVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, var, eventtype, eventhdlr, eventdata, filterpos) end function SCIPcatchRowEvent(scip, row, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPcatchRowEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, row, eventtype, eventhdlr, eventdata, filterpos) + ccall((:SCIPcatchRowEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, row, eventtype, eventhdlr, eventdata, filterpos) end function SCIPdropRowEvent(scip, row, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPdropRowEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, row, eventtype, eventhdlr, eventdata, filterpos) + ccall((:SCIPdropRowEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, row, eventtype, eventhdlr, eventdata, filterpos) end diff --git a/src/wrapper/scip_expr.jl b/src/wrapper/scip_expr.jl index 35df1e76..d78b4388 100644 --- a/src/wrapper/scip_expr.jl +++ b/src/wrapper/scip_expr.jl @@ -3,17 +3,17 @@ function SCIPgetExprtreeTransformedVars(scip, tree) - ccall((:SCIPgetExprtreeTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}), scip, tree) + ccall((:SCIPgetExprtreeTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EXPRTREE}), scip, tree) end function SCIPevalExprtreeSol(scip, tree, sol, val) - ccall((:SCIPevalExprtreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, tree, sol, val) + ccall((:SCIPevalExprtreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EXPRTREE}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, tree, sol, val) end function SCIPevalExprtreeGlobalBounds(scip, tree, infinity, val) - ccall((:SCIPevalExprtreeGlobalBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Cdouble, Ptr{Cint}), scip, tree, infinity, val) + ccall((:SCIPevalExprtreeGlobalBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EXPRTREE}, Cdouble, Ptr{Cint}), scip, tree, infinity, val) end function SCIPevalExprtreeLocalBounds(scip, tree, infinity, val) - ccall((:SCIPevalExprtreeLocalBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRTREE}, Cdouble, Ptr{Cint}), scip, tree, infinity, val) + ccall((:SCIPevalExprtreeLocalBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EXPRTREE}, Cdouble, Ptr{Cint}), scip, tree, infinity, val) end diff --git a/src/wrapper/scip_general.jl b/src/wrapper/scip_general.jl index aa1cb39b..43a646d6 100644 --- a/src/wrapper/scip_general.jl +++ b/src/wrapper/scip_general.jl @@ -23,11 +23,11 @@ function SCIPsubversion() end function SCIPprintVersion(scip, file) - ccall((:SCIPprintVersion, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintVersion, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintBuildOptions(scip, file) - ccall((:SCIPprintBuildOptions, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintBuildOptions, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintError(retcode) @@ -35,69 +35,69 @@ function SCIPprintError(retcode) end function SCIPcreate(scip) - ccall((:SCIPcreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP}},), scip) + ccall((:SCIPcreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_}},), scip) end function SCIPfree(scip) - ccall((:SCIPfree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP}},), scip) + ccall((:SCIPfree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_}},), scip) end function SCIPgetStage(scip) - ccall((:SCIPgetStage, libscip), SCIP_STAGE, (Ptr{SCIP},), scip) + ccall((:SCIPgetStage, libscip), SCIP_STAGE, (Ptr{SCIP_},), scip) end function SCIPprintStage(scip, file) - ccall((:SCIPprintStage, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintStage, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPgetStatus(scip) - ccall((:SCIPgetStatus, libscip), SCIP_STATUS, (Ptr{SCIP},), scip) + ccall((:SCIPgetStatus, libscip), SCIP_STATUS, (Ptr{SCIP_},), scip) end function SCIPprintStatus(scip, file) - ccall((:SCIPprintStatus, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintStatus, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPisTransformed(scip) - ccall((:SCIPisTransformed, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisTransformed, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPisExactSolve(scip) - ccall((:SCIPisExactSolve, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisExactSolve, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPisPresolveFinished(scip) - ccall((:SCIPisPresolveFinished, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisPresolveFinished, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPhasPerformedPresolve(scip) - ccall((:SCIPhasPerformedPresolve, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPhasPerformedPresolve, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPpressedCtrlC(scip) - ccall((:SCIPpressedCtrlC, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPpressedCtrlC, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPisStopped(scip) - ccall((:SCIPisStopped, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisStopped, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPincludeExternalCodeInformation(scip, name, description) - ccall((:SCIPincludeExternalCodeInformation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, name, description) + ccall((:SCIPincludeExternalCodeInformation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring), scip, name, description) end function SCIPgetExternalCodeNames(scip) - ccall((:SCIPgetExternalCodeNames, libscip), Ptr{Cstring}, (Ptr{SCIP},), scip) + ccall((:SCIPgetExternalCodeNames, libscip), Ptr{Cstring}, (Ptr{SCIP_},), scip) end function SCIPgetExternalCodeDescriptions(scip) - ccall((:SCIPgetExternalCodeDescriptions, libscip), Ptr{Cstring}, (Ptr{SCIP},), scip) + ccall((:SCIPgetExternalCodeDescriptions, libscip), Ptr{Cstring}, (Ptr{SCIP_},), scip) end function SCIPgetNExternalCodes(scip) - ccall((:SCIPgetNExternalCodes, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNExternalCodes, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPprintExternalCodes(scip, file) - ccall((:SCIPprintExternalCodes, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintExternalCodes, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end diff --git a/src/wrapper/scip_heur.jl b/src/wrapper/scip_heur.jl index a88a2fc2..a3a575c5 100644 --- a/src/wrapper/scip_heur.jl +++ b/src/wrapper/scip_heur.jl @@ -3,53 +3,53 @@ function SCIPincludeHeur(scip, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) - ccall((:SCIPincludeHeur, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt8, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) + ccall((:SCIPincludeHeur, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, UInt8, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurcopy, heurfree, heurinit, heurexit, heurinitsol, heurexitsol, heurexec, heurdata) end function SCIPincludeHeurBasic(scip, heur, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurexec, heurdata) - ccall((:SCIPincludeHeurBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_HEUR}}, Cstring, Cstring, UInt8, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, UInt32, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, heur, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurexec, heurdata) + ccall((:SCIPincludeHeurBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_HEUR}}, Cstring, Cstring, UInt8, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, UInt32, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, heur, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurexec, heurdata) end function SCIPsetHeurCopy(scip, heur, heurcopy) - ccall((:SCIPsetHeurCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurcopy) + ccall((:SCIPsetHeurCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurcopy) end function SCIPsetHeurFree(scip, heur, heurfree) - ccall((:SCIPsetHeurFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurfree) + ccall((:SCIPsetHeurFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurfree) end function SCIPsetHeurInit(scip, heur, heurinit) - ccall((:SCIPsetHeurInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinit) + ccall((:SCIPsetHeurInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinit) end function SCIPsetHeurExit(scip, heur, heurexit) - ccall((:SCIPsetHeurExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexit) + ccall((:SCIPsetHeurExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexit) end function SCIPsetHeurInitsol(scip, heur, heurinitsol) - ccall((:SCIPsetHeurInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinitsol) + ccall((:SCIPsetHeurInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinitsol) end function SCIPsetHeurExitsol(scip, heur, heurexitsol) - ccall((:SCIPsetHeurExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexitsol) + ccall((:SCIPsetHeurExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexitsol) end function SCIPfindHeur(scip, name) - ccall((:SCIPfindHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetHeurs(scip) - ccall((:SCIPgetHeurs, libscip), Ptr{Ptr{SCIP_HEUR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetHeurs, libscip), Ptr{Ptr{SCIP_HEUR}}, (Ptr{SCIP_},), scip) end function SCIPgetNHeurs(scip) - ccall((:SCIPgetNHeurs, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNHeurs, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetHeurPriority(scip, heur, priority) - ccall((:SCIPsetHeurPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Cint), scip, heur, priority) + ccall((:SCIPsetHeurPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, Cint), scip, heur, priority) end function SCIPcreateDiveset(scip, diveset, heur, name, minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol, maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack, onlylpbranchcands, specificsos1score, divesetgetscore) - ccall((:SCIPcreateDiveset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIVESET}}, Ptr{SCIP_HEUR}, Cstring, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}), scip, diveset, heur, name, minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol, maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack, onlylpbranchcands, specificsos1score, divesetgetscore) + ccall((:SCIPcreateDiveset, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_DIVESET}}, Ptr{SCIP_HEUR}, Cstring, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, UInt32, UInt32, UInt32, UInt32, Ptr{Cvoid}), scip, diveset, heur, name, minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol, maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack, onlylpbranchcands, specificsos1score, divesetgetscore) end diff --git a/src/wrapper/scip_lp.jl b/src/wrapper/scip_lp.jl index 1f20174a..4aa6d855 100644 --- a/src/wrapper/scip_lp.jl +++ b/src/wrapper/scip_lp.jl @@ -3,365 +3,365 @@ function SCIPhasCurrentNodeLP(scip) - ccall((:SCIPhasCurrentNodeLP, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPhasCurrentNodeLP, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPisLPConstructed(scip) - ccall((:SCIPisLPConstructed, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisLPConstructed, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPconstructLP(scip, cutoff) - ccall((:SCIPconstructLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) + ccall((:SCIPconstructLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{UInt32}), scip, cutoff) end function SCIPflushLP(scip) - ccall((:SCIPflushLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPflushLP, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPgetLPSolstat(scip) - ccall((:SCIPgetLPSolstat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPSolstat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP_},), scip) end function SCIPisLPPrimalReliable(scip) - ccall((:SCIPisLPPrimalReliable, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisLPPrimalReliable, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPisLPDualReliable(scip) - ccall((:SCIPisLPDualReliable, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisLPDualReliable, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPisLPRelax(scip) - ccall((:SCIPisLPRelax, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisLPRelax, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetLPObjval(scip) - ccall((:SCIPgetLPObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLPColumnObjval(scip) - ccall((:SCIPgetLPColumnObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPColumnObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLPLooseObjval(scip) - ccall((:SCIPgetLPLooseObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPLooseObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetGlobalPseudoObjval(scip) - ccall((:SCIPgetGlobalPseudoObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetGlobalPseudoObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetPseudoObjval(scip) - ccall((:SCIPgetPseudoObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetPseudoObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPisRootLPRelax(scip) - ccall((:SCIPisRootLPRelax, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisRootLPRelax, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetLPRootObjval(scip) - ccall((:SCIPgetLPRootObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPRootObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLPRootColumnObjval(scip) - ccall((:SCIPgetLPRootColumnObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPRootColumnObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLPRootLooseObjval(scip) - ccall((:SCIPgetLPRootLooseObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPRootLooseObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLPColsData(scip, cols, ncols) - ccall((:SCIPgetLPColsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_COL}}}, Ptr{Cint}), scip, cols, ncols) + ccall((:SCIPgetLPColsData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_COL}}}, Ptr{Cint}), scip, cols, ncols) end function SCIPgetLPCols(scip) - ccall((:SCIPgetLPCols, libscip), Ptr{Ptr{SCIP_COL}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPCols, libscip), Ptr{Ptr{SCIP_COL}}, (Ptr{SCIP_},), scip) end function SCIPgetNLPCols(scip) - ccall((:SCIPgetNLPCols, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPCols, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetLPRowsData(scip, rows, nrows) - ccall((:SCIPgetLPRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_ROW}}}, Ptr{Cint}), scip, rows, nrows) + ccall((:SCIPgetLPRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_ROW}}}, Ptr{Cint}), scip, rows, nrows) end function SCIPgetLPRows(scip) - ccall((:SCIPgetLPRows, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetLPRows, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP_},), scip) end function SCIPgetNLPRows(scip) - ccall((:SCIPgetNLPRows, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPRows, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPallColsInLP(scip) - ccall((:SCIPallColsInLP, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPallColsInLP, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPisLPSolBasic(scip) - ccall((:SCIPisLPSolBasic, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisLPSolBasic, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetLPBasisInd(scip, basisind) - ccall((:SCIPgetLPBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, basisind) + ccall((:SCIPgetLPBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cint}), scip, basisind) end function SCIPgetLPBInvRow(scip, r, coefs, inds, ninds) - ccall((:SCIPgetLPBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, coefs, inds, ninds) + ccall((:SCIPgetLPBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, coefs, inds, ninds) end function SCIPgetLPBInvCol(scip, c, coefs, inds, ninds) - ccall((:SCIPgetLPBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) + ccall((:SCIPgetLPBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) end function SCIPgetLPBInvARow(scip, r, binvrow, coefs, inds, ninds) - ccall((:SCIPgetLPBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, binvrow, coefs, inds, ninds) + ccall((:SCIPgetLPBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, binvrow, coefs, inds, ninds) end function SCIPgetLPBInvACol(scip, c, coefs, inds, ninds) - ccall((:SCIPgetLPBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) + ccall((:SCIPgetLPBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) end function SCIPsumLPRows(scip, weights, sumcoef, sumlhs, sumrhs) - ccall((:SCIPsumLPRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}, Ptr{SCIP_REALARRAY}, Ptr{Cdouble}, Ptr{Cdouble}), scip, weights, sumcoef, sumlhs, sumrhs) + ccall((:SCIPsumLPRows, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cdouble}, Ptr{SCIP_REALARRAY}, Ptr{Cdouble}, Ptr{Cdouble}), scip, weights, sumcoef, sumlhs, sumrhs) end function SCIPwriteLP(scip, filename) - ccall((:SCIPwriteLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) + ccall((:SCIPwriteLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, filename) end function SCIPwriteMIP(scip, filename, genericnames, origobj, lazyconss) - ccall((:SCIPwriteMIP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32, UInt32, UInt32), scip, filename, genericnames, origobj, lazyconss) + ccall((:SCIPwriteMIP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, UInt32, UInt32, UInt32), scip, filename, genericnames, origobj, lazyconss) end function SCIPgetLPI(scip, lpi) - ccall((:SCIPgetLPI, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LPI}}), scip, lpi) + ccall((:SCIPgetLPI, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_LPI}}), scip, lpi) end function SCIPprintLPSolutionQuality(scip, file) - ccall((:SCIPprintLPSolutionQuality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintLPSolutionQuality, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPcomputeLPRelIntPoint(scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) - ccall((:SCIPcomputeLPRelIntPoint, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, Cdouble, Cint, Ptr{Ptr{SCIP_SOL}}), scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) + ccall((:SCIPcomputeLPRelIntPoint, libscip), SCIP_RETCODE, (Ptr{SCIP_}, UInt32, UInt32, Cdouble, Cint, Ptr{Ptr{SCIP_SOL}}), scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) end function SCIPgetColRedcost(scip, col) - ccall((:SCIPgetColRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) + ccall((:SCIPgetColRedcost, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_COL}), scip, col) end function SCIPgetColFarkasCoef(scip, col) - ccall((:SCIPgetColFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) + ccall((:SCIPgetColFarkasCoef, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_COL}), scip, col) end function SCIPmarkColNotRemovableLocal(scip, col) - ccall((:SCIPmarkColNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) + ccall((:SCIPmarkColNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_COL}), scip, col) end function SCIPcreateRowCons(scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) end function SCIPcreateRowSepa(scip, row, sepa, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_SEPA}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, sepa, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_SEPA}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, sepa, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) end function SCIPcreateRowUnspec(scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateRowUnspec, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateRowUnspec, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) end function SCIPcreateRow(scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) end function SCIPcreateEmptyRowCons(scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateEmptyRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateEmptyRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) end function SCIPcreateEmptyRowSepa(scip, row, sepa, name, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateEmptyRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_SEPA}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, sepa, name, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateEmptyRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_SEPA}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, sepa, name, lhs, rhs, _local, modifiable, removable) end function SCIPcreateEmptyRowUnspec(scip, row, name, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateEmptyRowUnspec, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateEmptyRowUnspec, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, lhs, rhs, _local, modifiable, removable) end function SCIPcreateEmptyRow(scip, row, name, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateEmptyRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateEmptyRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}, Cstring, Cdouble, Cdouble, UInt32, UInt32, UInt32), scip, row, name, lhs, rhs, _local, modifiable, removable) end function SCIPcaptureRow(scip, row) - ccall((:SCIPcaptureRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPcaptureRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPreleaseRow(scip, row) - ccall((:SCIPreleaseRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}), scip, row) + ccall((:SCIPreleaseRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_ROW}}), scip, row) end function SCIPchgRowLhs(scip, row, lhs) - ccall((:SCIPchgRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, lhs) + ccall((:SCIPchgRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Cdouble), scip, row, lhs) end function SCIPchgRowRhs(scip, row, rhs) - ccall((:SCIPchgRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, rhs) + ccall((:SCIPchgRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Cdouble), scip, row, rhs) end function SCIPcacheRowExtensions(scip, row) - ccall((:SCIPcacheRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPcacheRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPflushRowExtensions(scip, row) - ccall((:SCIPflushRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPflushRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPaddVarToRow(scip, row, var, val) - ccall((:SCIPaddVarToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_VAR}, Cdouble), scip, row, var, val) + ccall((:SCIPaddVarToRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Ptr{SCIP_VAR}, Cdouble), scip, row, var, val) end function SCIPaddVarsToRow(scip, row, nvars, vars, vals) - ccall((:SCIPaddVarsToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, row, nvars, vars, vals) + ccall((:SCIPaddVarsToRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, row, nvars, vars, vals) end function SCIPaddVarsToRowSameCoef(scip, row, nvars, vars, val) - ccall((:SCIPaddVarsToRowSameCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Cdouble), scip, row, nvars, vars, val) + ccall((:SCIPaddVarsToRowSameCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Cdouble), scip, row, nvars, vars, val) end function SCIPcalcRowIntegralScalar(scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) - ccall((:SCIPcalcRowIntegralScalar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Clonglong, Cdouble, UInt32, Ptr{Cdouble}, Ptr{UInt32}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) + ccall((:SCIPcalcRowIntegralScalar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Clonglong, Cdouble, UInt32, Ptr{Cdouble}, Ptr{UInt32}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) end function SCIPmakeRowIntegral(scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) - ccall((:SCIPmakeRowIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Clonglong, Cdouble, UInt32, Ptr{UInt32}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) + ccall((:SCIPmakeRowIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Clonglong, Cdouble, UInt32, Ptr{UInt32}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) end function SCIPmarkRowNotRemovableLocal(scip, row) - ccall((:SCIPmarkRowNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPmarkRowNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowNumIntCols(scip, row) - ccall((:SCIPgetRowNumIntCols, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowNumIntCols, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowMinCoef(scip, row) - ccall((:SCIPgetRowMinCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowMinCoef, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowMaxCoef(scip, row) - ccall((:SCIPgetRowMaxCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowMaxCoef, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowMinActivity(scip, row) - ccall((:SCIPgetRowMinActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowMinActivity, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowMaxActivity(scip, row) - ccall((:SCIPgetRowMaxActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowMaxActivity, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPrecalcRowLPActivity(scip, row) - ccall((:SCIPrecalcRowLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPrecalcRowLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowLPActivity(scip, row) - ccall((:SCIPgetRowLPActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowLPActivity, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowLPFeasibility(scip, row) - ccall((:SCIPgetRowLPFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowLPFeasibility, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPrecalcRowPseudoActivity(scip, row) - ccall((:SCIPrecalcRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPrecalcRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowPseudoActivity(scip, row) - ccall((:SCIPgetRowPseudoActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowPseudoActivity, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowPseudoFeasibility(scip, row) - ccall((:SCIPgetRowPseudoFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowPseudoFeasibility, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPrecalcRowActivity(scip, row) - ccall((:SCIPrecalcRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPrecalcRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowActivity(scip, row) - ccall((:SCIPgetRowActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowActivity, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowFeasibility(scip, row) - ccall((:SCIPgetRowFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPgetRowFeasibility, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowSolActivity(scip, row, sol) - ccall((:SCIPgetRowSolActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) + ccall((:SCIPgetRowSolActivity, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) end function SCIPgetRowSolFeasibility(scip, row, sol) - ccall((:SCIPgetRowSolFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) + ccall((:SCIPgetRowSolFeasibility, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) end function SCIPprintRow(scip, row, file) - ccall((:SCIPprintRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{FILE}), scip, row, file) + ccall((:SCIPprintRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Ptr{FILE}), scip, row, file) end function SCIPstartDive(scip) - ccall((:SCIPstartDive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPstartDive, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPendDive(scip) - ccall((:SCIPendDive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPendDive, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPchgCutoffboundDive(scip, newcutoffbound) - ccall((:SCIPchgCutoffboundDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newcutoffbound) + ccall((:SCIPchgCutoffboundDive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, newcutoffbound) end function SCIPchgVarObjDive(scip, var, newobj) - ccall((:SCIPchgVarObjDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) + ccall((:SCIPchgVarObjDive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end function SCIPchgVarLbDive(scip, var, newbound) - ccall((:SCIPchgVarLbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall((:SCIPchgVarLbDive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarUbDive(scip, var, newbound) - ccall((:SCIPchgVarUbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall((:SCIPchgVarUbDive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPaddRowDive(scip, row) - ccall((:SCIPaddRowDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPaddRowDive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPchgRowLhsDive(scip, row, newlhs) - ccall((:SCIPchgRowLhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newlhs) + ccall((:SCIPchgRowLhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Cdouble), scip, row, newlhs) end function SCIPchgRowRhsDive(scip, row, newrhs) - ccall((:SCIPchgRowRhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newrhs) + ccall((:SCIPchgRowRhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}, Cdouble), scip, row, newrhs) end function SCIPgetVarObjDive(scip, var) - ccall((:SCIPgetVarObjDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarObjDive, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarLbDive(scip, var) - ccall((:SCIPgetVarLbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarLbDive, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarUbDive(scip, var) - ccall((:SCIPgetVarUbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarUbDive, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPsolveDiveLP(scip, itlim, lperror, cutoff) - ccall((:SCIPsolveDiveLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, itlim, lperror, cutoff) + ccall((:SCIPsolveDiveLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, itlim, lperror, cutoff) end function SCIPgetLastDivenode(scip) - ccall((:SCIPgetLastDivenode, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetLastDivenode, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPinDive(scip) - ccall((:SCIPinDive, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPinDive, libscip), UInt32, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_mem.jl b/src/wrapper/scip_mem.jl index 8528a740..24e59334 100644 --- a/src/wrapper/scip_mem.jl +++ b/src/wrapper/scip_mem.jl @@ -3,37 +3,37 @@ function SCIPblkmem(scip) - ccall((:SCIPblkmem, libscip), Ptr{BMS_BLKMEM}, (Ptr{SCIP},), scip) + ccall((:SCIPblkmem, libscip), Ptr{BMS_BLKMEM}, (Ptr{SCIP_},), scip) end function SCIPbuffer(scip) - ccall((:SCIPbuffer, libscip), Ptr{BMS_BUFMEM}, (Ptr{SCIP},), scip) + ccall((:SCIPbuffer, libscip), Ptr{BMS_BUFMEM}, (Ptr{SCIP_},), scip) end function SCIPcleanbuffer(scip) - ccall((:SCIPcleanbuffer, libscip), Ptr{BMS_BUFMEM}, (Ptr{SCIP},), scip) + ccall((:SCIPcleanbuffer, libscip), Ptr{BMS_BUFMEM}, (Ptr{SCIP_},), scip) end function SCIPgetMemUsed(scip) - ccall((:SCIPgetMemUsed, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetMemUsed, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetMemTotal(scip) - ccall((:SCIPgetMemTotal, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetMemTotal, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetMemExternEstim(scip) - ccall((:SCIPgetMemExternEstim, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetMemExternEstim, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPcalcMemGrowSize(scip, num) - ccall((:SCIPcalcMemGrowSize, libscip), Cint, (Ptr{SCIP}, Cint), scip, num) + ccall((:SCIPcalcMemGrowSize, libscip), Cint, (Ptr{SCIP_}, Cint), scip, num) end function SCIPensureBlockMemoryArray_call(scip, arrayptr, elemsize, arraysize, minsize) - ccall((:SCIPensureBlockMemoryArray_call, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cint}, Cint), scip, arrayptr, elemsize, arraysize, minsize) + ccall((:SCIPensureBlockMemoryArray_call, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cint}, Cint), scip, arrayptr, elemsize, arraysize, minsize) end function SCIPprintMemoryDiagnostic(scip) - ccall((:SCIPprintMemoryDiagnostic, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPprintMemoryDiagnostic, libscip), Cvoid, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_message.jl b/src/wrapper/scip_message.jl index c7a1a149..22db6ee8 100644 --- a/src/wrapper/scip_message.jl +++ b/src/wrapper/scip_message.jl @@ -3,21 +3,21 @@ function SCIPsetMessagehdlr(scip, messagehdlr) - ccall((:SCIPsetMessagehdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_MESSAGEHDLR}), scip, messagehdlr) + ccall((:SCIPsetMessagehdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_MESSAGEHDLR}), scip, messagehdlr) end function SCIPgetMessagehdlr(scip) - ccall((:SCIPgetMessagehdlr, libscip), Ptr{SCIP_MESSAGEHDLR}, (Ptr{SCIP},), scip) + ccall((:SCIPgetMessagehdlr, libscip), Ptr{SCIP_MESSAGEHDLR}, (Ptr{SCIP_},), scip) end function SCIPsetMessagehdlrLogfile(scip, filename) - ccall((:SCIPsetMessagehdlrLogfile, libscip), Cvoid, (Ptr{SCIP}, Cstring), scip, filename) + ccall((:SCIPsetMessagehdlrLogfile, libscip), Cvoid, (Ptr{SCIP_}, Cstring), scip, filename) end function SCIPsetMessagehdlrQuiet(scip, quiet) - ccall((:SCIPsetMessagehdlrQuiet, libscip), Cvoid, (Ptr{SCIP}, UInt32), scip, quiet) + ccall((:SCIPsetMessagehdlrQuiet, libscip), Cvoid, (Ptr{SCIP_}, UInt32), scip, quiet) end function SCIPgetVerbLevel(scip) - ccall((:SCIPgetVerbLevel, libscip), SCIP_VERBLEVEL, (Ptr{SCIP},), scip) + ccall((:SCIPgetVerbLevel, libscip), SCIP_VERBLEVEL, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_nlp.jl b/src/wrapper/scip_nlp.jl index d67615b5..bab3d803 100644 --- a/src/wrapper/scip_nlp.jl +++ b/src/wrapper/scip_nlp.jl @@ -3,301 +3,301 @@ function SCIPincludeNlpi(scip, nlpi) - ccall((:SCIPincludeNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}), scip, nlpi) + ccall((:SCIPincludeNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLPI}), scip, nlpi) end function SCIPfindNlpi(scip, name) - ccall((:SCIPfindNlpi, libscip), Ptr{SCIP_NLPI}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindNlpi, libscip), Ptr{SCIP_NLPI}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetNlpis(scip) - ccall((:SCIPgetNlpis, libscip), Ptr{Ptr{SCIP_NLPI}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetNlpis, libscip), Ptr{Ptr{SCIP_NLPI}}, (Ptr{SCIP_},), scip) end function SCIPgetNNlpis(scip) - ccall((:SCIPgetNNlpis, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNlpis, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetNlpiPriority(scip, nlpi, priority) - ccall((:SCIPsetNlpiPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Cint), scip, nlpi, priority) + ccall((:SCIPsetNlpiPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLPI}, Cint), scip, nlpi, priority) end function SCIPisNLPEnabled(scip) - ccall((:SCIPisNLPEnabled, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisNLPEnabled, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPenableNLP(scip) - ccall((:SCIPenableNLP, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPenableNLP, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPisNLPConstructed(scip) - ccall((:SCIPisNLPConstructed, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisNLPConstructed, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPhasNLPContinuousNonlinearity(scip) - ccall((:SCIPhasNLPContinuousNonlinearity, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPhasNLPContinuousNonlinearity, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetNLPVarsData(scip, vars, nvars) - ccall((:SCIPgetNLPVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}), scip, vars, nvars) + ccall((:SCIPgetNLPVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}), scip, vars, nvars) end function SCIPgetNLPVars(scip) - ccall((:SCIPgetNLPVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_},), scip) end function SCIPgetNNLPVars(scip) - ccall((:SCIPgetNNLPVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNLPVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNLPVarsNonlinearity(scip, nlcount) - ccall((:SCIPgetNLPVarsNonlinearity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, nlcount) + ccall((:SCIPgetNLPVarsNonlinearity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cint}), scip, nlcount) end function SCIPgetNLPVarsLbDualsol(scip) - ccall((:SCIPgetNLPVarsLbDualsol, libscip), Ptr{Cdouble}, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPVarsLbDualsol, libscip), Ptr{Cdouble}, (Ptr{SCIP_},), scip) end function SCIPgetNLPVarsUbDualsol(scip) - ccall((:SCIPgetNLPVarsUbDualsol, libscip), Ptr{Cdouble}, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPVarsUbDualsol, libscip), Ptr{Cdouble}, (Ptr{SCIP_},), scip) end function SCIPgetNLPNlRowsData(scip, nlrows, nnlrows) - ccall((:SCIPgetNLPNlRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NLROW}}}, Ptr{Cint}), scip, nlrows, nnlrows) + ccall((:SCIPgetNLPNlRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_NLROW}}}, Ptr{Cint}), scip, nlrows, nnlrows) end function SCIPgetNLPNlRows(scip) - ccall((:SCIPgetNLPNlRows, libscip), Ptr{Ptr{SCIP_NLROW}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPNlRows, libscip), Ptr{Ptr{SCIP_NLROW}}, (Ptr{SCIP_},), scip) end function SCIPgetNNLPNlRows(scip) - ccall((:SCIPgetNNLPNlRows, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNLPNlRows, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPaddNlRow(scip, nlrow) - ccall((:SCIPaddNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall((:SCIPaddNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPflushNLP(scip) - ccall((:SCIPflushNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPflushNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPsetNLPInitialGuess(scip, initialguess) - ccall((:SCIPsetNLPInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}), scip, initialguess) + ccall((:SCIPsetNLPInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cdouble}), scip, initialguess) end function SCIPsetNLPInitialGuessSol(scip, sol) - ccall((:SCIPsetNLPInitialGuessSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPsetNLPInitialGuessSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPsolveNLP(scip) - ccall((:SCIPsolveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPsolveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPgetNLPSolstat(scip) - ccall((:SCIPgetNLPSolstat, libscip), SCIP_NLPSOLSTAT, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPSolstat, libscip), SCIP_NLPSOLSTAT, (Ptr{SCIP_},), scip) end function SCIPgetNLPTermstat(scip) - ccall((:SCIPgetNLPTermstat, libscip), SCIP_NLPTERMSTAT, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPTermstat, libscip), SCIP_NLPTERMSTAT, (Ptr{SCIP_},), scip) end function SCIPgetNLPStatistics(scip, statistics) - ccall((:SCIPgetNLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPSTATISTICS}), scip, statistics) + ccall((:SCIPgetNLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLPSTATISTICS}), scip, statistics) end function SCIPgetNLPObjval(scip) - ccall((:SCIPgetNLPObjval, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPObjval, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPhasNLPSolution(scip) - ccall((:SCIPhasNLPSolution, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPhasNLPSolution, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetNLPFracVars(scip, fracvars, fracvarssol, fracvarsfrac, nfracvars, npriofracvars) - ccall((:SCIPgetNLPFracVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}), scip, fracvars, fracvarssol, fracvarsfrac, nfracvars, npriofracvars) + ccall((:SCIPgetNLPFracVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}), scip, fracvars, fracvarssol, fracvarsfrac, nfracvars, npriofracvars) end function SCIPgetNLPIntPar(scip, type, ival) - ccall((:SCIPgetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cint}), scip, type, ival) + ccall((:SCIPgetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_NLPPARAM, Ptr{Cint}), scip, type, ival) end function SCIPsetNLPIntPar(scip, type, ival) - ccall((:SCIPsetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cint), scip, type, ival) + ccall((:SCIPsetNLPIntPar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_NLPPARAM, Cint), scip, type, ival) end function SCIPgetNLPRealPar(scip, type, dval) - ccall((:SCIPgetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cdouble}), scip, type, dval) + ccall((:SCIPgetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_NLPPARAM, Ptr{Cdouble}), scip, type, dval) end function SCIPsetNLPRealPar(scip, type, dval) - ccall((:SCIPsetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cdouble), scip, type, dval) + ccall((:SCIPsetNLPRealPar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_NLPPARAM, Cdouble), scip, type, dval) end function SCIPgetNLPStringPar(scip, type, sval) - ccall((:SCIPgetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Ptr{Cstring}), scip, type, sval) + ccall((:SCIPgetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_NLPPARAM, Ptr{Cstring}), scip, type, sval) end function SCIPsetNLPStringPar(scip, type, sval) - ccall((:SCIPsetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM, Cstring), scip, type, sval) + ccall((:SCIPsetNLPStringPar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_NLPPARAM, Cstring), scip, type, sval) end function SCIPwriteNLP(scip, filename) - ccall((:SCIPwriteNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) + ccall((:SCIPwriteNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, filename) end function SCIPgetNLPI(scip, nlpi, nlpiproblem) - ccall((:SCIPgetNLPI, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLPI}}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), scip, nlpi, nlpiproblem) + ccall((:SCIPgetNLPI, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_NLPI}}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), scip, nlpi, nlpiproblem) end function SCIPstartDiveNLP(scip) - ccall((:SCIPstartDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPstartDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPendDiveNLP(scip) - ccall((:SCIPendDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPendDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPchgVarObjDiveNLP(scip, var, coef) - ccall((:SCIPchgVarObjDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, coef) + ccall((:SCIPchgVarObjDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, coef) end function SCIPchgVarBoundsDiveNLP(scip, var, lb, ub) - ccall((:SCIPchgVarBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, lb, ub) + ccall((:SCIPchgVarBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, lb, ub) end function SCIPchgVarsBoundsDiveNLP(scip, nvars, vars, lbs, ubs) - ccall((:SCIPchgVarsBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nvars, vars, lbs, ubs) + ccall((:SCIPchgVarsBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nvars, vars, lbs, ubs) end function SCIPsolveDiveNLP(scip) - ccall((:SCIPsolveDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPsolveDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPcreateNlRow(scip, nlrow, name, constant, nlinvars, linvars, lincoefs, nquadvars, quadvars, nquadelems, quadelems, expression, lhs, rhs, curvature) - ccall((:SCIPcreateNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Cstring, Cdouble, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{SCIP_QUADELEM}, Ptr{SCIP_EXPRTREE}, Cdouble, Cdouble, SCIP_EXPRCURV), scip, nlrow, name, constant, nlinvars, linvars, lincoefs, nquadvars, quadvars, nquadelems, quadelems, expression, lhs, rhs, curvature) + ccall((:SCIPcreateNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_NLROW}}, Cstring, Cdouble, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{SCIP_QUADELEM}, Ptr{SCIP_EXPRTREE}, Cdouble, Cdouble, SCIP_EXPRCURV), scip, nlrow, name, constant, nlinvars, linvars, lincoefs, nquadvars, quadvars, nquadelems, quadelems, expression, lhs, rhs, curvature) end function SCIPcreateEmptyNlRow(scip, nlrow, name, lhs, rhs) - ccall((:SCIPcreateEmptyNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Cstring, Cdouble, Cdouble), scip, nlrow, name, lhs, rhs) + ccall((:SCIPcreateEmptyNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_NLROW}}, Cstring, Cdouble, Cdouble), scip, nlrow, name, lhs, rhs) end function SCIPcreateNlRowFromRow(scip, nlrow, row) - ccall((:SCIPcreateNlRowFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{SCIP_ROW}), scip, nlrow, row) + ccall((:SCIPcreateNlRowFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_NLROW}}, Ptr{SCIP_ROW}), scip, nlrow, row) end function SCIPcaptureNlRow(scip, nlrow) - ccall((:SCIPcaptureNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall((:SCIPcaptureNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPreleaseNlRow(scip, nlrow) - ccall((:SCIPreleaseNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}), scip, nlrow) + ccall((:SCIPreleaseNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_NLROW}}), scip, nlrow) end function SCIPchgNlRowLhs(scip, nlrow, lhs) - ccall((:SCIPchgNlRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, lhs) + ccall((:SCIPchgNlRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, lhs) end function SCIPchgNlRowRhs(scip, nlrow, rhs) - ccall((:SCIPchgNlRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, rhs) + ccall((:SCIPchgNlRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, rhs) end function SCIPchgNlRowConstant(scip, nlrow, constant) - ccall((:SCIPchgNlRowConstant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, constant) + ccall((:SCIPchgNlRowConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, constant) end function SCIPaddLinearCoefToNlRow(scip, nlrow, var, val) - ccall((:SCIPaddLinearCoefToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, val) + ccall((:SCIPaddLinearCoefToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, val) end function SCIPaddLinearCoefsToNlRow(scip, nlrow, nvars, vars, vals) - ccall((:SCIPaddLinearCoefsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nlrow, nvars, vars, vals) + ccall((:SCIPaddLinearCoefsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nlrow, nvars, vars, vals) end function SCIPchgNlRowLinearCoef(scip, nlrow, var, coef) - ccall((:SCIPchgNlRowLinearCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, coef) + ccall((:SCIPchgNlRowLinearCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, coef) end function SCIPaddQuadVarToNlRow(scip, nlrow, var) - ccall((:SCIPaddQuadVarToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}), scip, nlrow, var) + ccall((:SCIPaddQuadVarToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}), scip, nlrow, var) end function SCIPaddQuadVarsToNlRow(scip, nlrow, nvars, vars) - ccall((:SCIPaddQuadVarsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, nlrow, nvars, vars) + ccall((:SCIPaddQuadVarsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, nlrow, nvars, vars) end function SCIPaddQuadElementToNlRow(scip, nlrow, quadelem) - ccall((:SCIPaddQuadElementToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_QUADELEM), scip, nlrow, quadelem) + ccall((:SCIPaddQuadElementToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, SCIP_QUADELEM), scip, nlrow, quadelem) end function SCIPaddQuadElementsToNlRow(scip, nlrow, nquadelems, quadelems) - ccall((:SCIPaddQuadElementsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{SCIP_QUADELEM}), scip, nlrow, nquadelems, quadelems) + ccall((:SCIPaddQuadElementsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Cint, Ptr{SCIP_QUADELEM}), scip, nlrow, nquadelems, quadelems) end function SCIPchgNlRowQuadElement(scip, nlrow, quadelement) - ccall((:SCIPchgNlRowQuadElement, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_QUADELEM), scip, nlrow, quadelement) + ccall((:SCIPchgNlRowQuadElement, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, SCIP_QUADELEM), scip, nlrow, quadelement) end function SCIPsetNlRowExprtree(scip, nlrow, exprtree) - ccall((:SCIPsetNlRowExprtree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_EXPRTREE}), scip, nlrow, exprtree) + ccall((:SCIPsetNlRowExprtree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{SCIP_EXPRTREE}), scip, nlrow, exprtree) end function SCIPsetNlRowExprtreeParam(scip, nlrow, paramidx, paramval) - ccall((:SCIPsetNlRowExprtreeParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Cdouble), scip, nlrow, paramidx, paramval) + ccall((:SCIPsetNlRowExprtreeParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Cint, Cdouble), scip, nlrow, paramidx, paramval) end function SCIPsetNlRowExprtreeParams(scip, nlrow, paramvals) - ccall((:SCIPsetNlRowExprtreeParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, paramvals) + ccall((:SCIPsetNlRowExprtreeParams, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, paramvals) end function SCIPrecalcNlRowNLPActivity(scip, nlrow) - ccall((:SCIPrecalcNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall((:SCIPrecalcNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPgetNlRowNLPActivity(scip, nlrow, activity) - ccall((:SCIPgetNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) + ccall((:SCIPgetNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) end function SCIPgetNlRowNLPFeasibility(scip, nlrow, feasibility) - ccall((:SCIPgetNlRowNLPFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) + ccall((:SCIPgetNlRowNLPFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) end function SCIPrecalcNlRowPseudoActivity(scip, nlrow) - ccall((:SCIPrecalcNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall((:SCIPrecalcNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPgetNlRowPseudoActivity(scip, nlrow, pseudoactivity) - ccall((:SCIPgetNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudoactivity) + ccall((:SCIPgetNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudoactivity) end function SCIPgetNlRowPseudoFeasibility(scip, nlrow, pseudofeasibility) - ccall((:SCIPgetNlRowPseudoFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudofeasibility) + ccall((:SCIPgetNlRowPseudoFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudofeasibility) end function SCIPrecalcNlRowActivity(scip, nlrow) - ccall((:SCIPrecalcNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall((:SCIPrecalcNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPgetNlRowActivity(scip, nlrow, activity) - ccall((:SCIPgetNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) + ccall((:SCIPgetNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) end function SCIPgetNlRowFeasibility(scip, nlrow, feasibility) - ccall((:SCIPgetNlRowFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) + ccall((:SCIPgetNlRowFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) end function SCIPgetNlRowSolActivity(scip, nlrow, sol, activity) - ccall((:SCIPgetNlRowSolActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, activity) + ccall((:SCIPgetNlRowSolActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, activity) end function SCIPgetNlRowSolFeasibility(scip, nlrow, sol, feasibility) - ccall((:SCIPgetNlRowSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, feasibility) + ccall((:SCIPgetNlRowSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, feasibility) end function SCIPgetNlRowActivityBounds(scip, nlrow, minactivity, maxactivity) - ccall((:SCIPgetNlRowActivityBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlrow, minactivity, maxactivity) + ccall((:SCIPgetNlRowActivityBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlrow, minactivity, maxactivity) end function SCIPprintNlRow(scip, nlrow, file) - ccall((:SCIPprintNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{FILE}), scip, nlrow, file) + ccall((:SCIPprintNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLROW}, Ptr{FILE}), scip, nlrow, file) end diff --git a/src/wrapper/scip_nodesel.jl b/src/wrapper/scip_nodesel.jl index 02e24942..6490e94c 100644 --- a/src/wrapper/scip_nodesel.jl +++ b/src/wrapper/scip_nodesel.jl @@ -3,57 +3,57 @@ function SCIPincludeNodesel(scip, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) - ccall((:SCIPincludeNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) + ccall((:SCIPincludeNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) end function SCIPincludeNodeselBasic(scip, nodesel, name, desc, stdpriority, memsavepriority, nodeselselect, nodeselcomp, nodeseldata) - ccall((:SCIPincludeNodeselBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NODESEL}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, nodesel, name, desc, stdpriority, memsavepriority, nodeselselect, nodeselcomp, nodeseldata) + ccall((:SCIPincludeNodeselBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_NODESEL}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, nodesel, name, desc, stdpriority, memsavepriority, nodeselselect, nodeselcomp, nodeseldata) end function SCIPsetNodeselCopy(scip, nodesel, nodeselcopy) - ccall((:SCIPsetNodeselCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselcopy) + ccall((:SCIPsetNodeselCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselcopy) end function SCIPsetNodeselFree(scip, nodesel, nodeselfree) - ccall((:SCIPsetNodeselFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselfree) + ccall((:SCIPsetNodeselFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselfree) end function SCIPsetNodeselInit(scip, nodesel, nodeselinit) - ccall((:SCIPsetNodeselInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinit) + ccall((:SCIPsetNodeselInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinit) end function SCIPsetNodeselExit(scip, nodesel, nodeselexit) - ccall((:SCIPsetNodeselExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexit) + ccall((:SCIPsetNodeselExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexit) end function SCIPsetNodeselInitsol(scip, nodesel, nodeselinitsol) - ccall((:SCIPsetNodeselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinitsol) + ccall((:SCIPsetNodeselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinitsol) end function SCIPsetNodeselExitsol(scip, nodesel, nodeselexitsol) - ccall((:SCIPsetNodeselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexitsol) + ccall((:SCIPsetNodeselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexitsol) end function SCIPfindNodesel(scip, name) - ccall((:SCIPfindNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetNodesels(scip) - ccall((:SCIPgetNodesels, libscip), Ptr{Ptr{SCIP_NODESEL}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetNodesels, libscip), Ptr{Ptr{SCIP_NODESEL}}, (Ptr{SCIP_},), scip) end function SCIPgetNNodesels(scip) - ccall((:SCIPgetNNodesels, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNodesels, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetNodeselStdPriority(scip, nodesel, priority) - ccall((:SCIPsetNodeselStdPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) + ccall((:SCIPsetNodeselStdPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) end function SCIPsetNodeselMemsavePriority(scip, nodesel, priority) - ccall((:SCIPsetNodeselMemsavePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) + ccall((:SCIPsetNodeselMemsavePriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) end function SCIPgetNodesel(scip) - ccall((:SCIPgetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP},), scip) + ccall((:SCIPgetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_nonlinear.jl b/src/wrapper/scip_nonlinear.jl index fbcd8747..dd88e7df 100644 --- a/src/wrapper/scip_nonlinear.jl +++ b/src/wrapper/scip_nonlinear.jl @@ -3,37 +3,37 @@ function SCIPaddSquareLinearization(scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) - ccall((:SCIPaddSquareLinearization, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, UInt32, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) + ccall((:SCIPaddSquareLinearization, libscip), Cvoid, (Ptr{SCIP_}, Cdouble, Cdouble, UInt32, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) end function SCIPaddSquareSecant(scip, sqrcoef, lb, ub, refpoint, lincoef, linconstant, success) - ccall((:SCIPaddSquareSecant, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, sqrcoef, lb, ub, refpoint, lincoef, linconstant, success) + ccall((:SCIPaddSquareSecant, libscip), Cvoid, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, sqrcoef, lb, ub, refpoint, lincoef, linconstant, success) end function SCIPaddBilinLinearization(scip, bilincoef, refpointx, refpointy, lincoefx, lincoefy, linconstant, success) - ccall((:SCIPaddBilinLinearization, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, refpointx, refpointy, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPaddBilinLinearization, libscip), Cvoid, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, refpointx, refpointy, lincoefx, lincoefy, linconstant, success) end function SCIPaddBilinMcCormick(scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, lincoefx, lincoefy, linconstant, success) - ccall((:SCIPaddBilinMcCormick, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPaddBilinMcCormick, libscip), Cvoid, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, lincoefx, lincoefy, linconstant, success) end function SCIPcomputeBilinEnvelope1(scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, xcoef, ycoef, constant, lincoefx, lincoefy, linconstant, success) - ccall((:SCIPcomputeBilinEnvelope1, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, xcoef, ycoef, constant, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPcomputeBilinEnvelope1, libscip), Cvoid, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, xcoef, ycoef, constant, lincoefx, lincoefy, linconstant, success) end function SCIPcomputeBilinEnvelope2(scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, alpha1, beta1, gamma1, alpha2, beta2, gamma2, lincoefx, lincoefy, linconstant, success) - ccall((:SCIPcomputeBilinEnvelope2, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, alpha1, beta1, gamma1, alpha2, beta2, gamma2, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPcomputeBilinEnvelope2, libscip), Cvoid, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, alpha1, beta1, gamma1, alpha2, beta2, gamma2, lincoefx, lincoefy, linconstant, success) end function SCIPcreateNlpiProb(scip, nlpi, nlrows, nnlrows, nlpiprob, var2idx, nlscore, cutoffbound, setobj, onlyconvex) - ccall((:SCIPcreateNlpiProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLROW}}, Cint, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Cdouble}, Cdouble, UInt32, UInt32), scip, nlpi, nlrows, nnlrows, nlpiprob, var2idx, nlscore, cutoffbound, setobj, onlyconvex) + ccall((:SCIPcreateNlpiProb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLROW}}, Cint, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Cdouble}, Cdouble, UInt32, UInt32), scip, nlpi, nlrows, nnlrows, nlpiprob, var2idx, nlscore, cutoffbound, setobj, onlyconvex) end function SCIPupdateNlpiProb(scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) - ccall((:SCIPupdateNlpiProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cdouble), scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) + ccall((:SCIPupdateNlpiProb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cdouble), scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) end function SCIPaddNlpiProbRows(scip, nlpi, nlpiprob, var2idx, rows, nrows) - ccall((:SCIPaddNlpiProbRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_ROW}}, Cint), scip, nlpi, nlpiprob, var2idx, rows, nrows) + ccall((:SCIPaddNlpiProbRows, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_ROW}}, Cint), scip, nlpi, nlpiprob, var2idx, rows, nrows) end diff --git a/src/wrapper/scip_numerics.jl b/src/wrapper/scip_numerics.jl index 4e4db339..9d03b69f 100644 --- a/src/wrapper/scip_numerics.jl +++ b/src/wrapper/scip_numerics.jl @@ -3,345 +3,345 @@ function SCIPepsilon(scip) - ccall((:SCIPepsilon, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPepsilon, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPsumepsilon(scip) - ccall((:SCIPsumepsilon, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPsumepsilon, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPfeastol(scip) - ccall((:SCIPfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPfeastol, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPlpfeastol(scip) - ccall((:SCIPlpfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPlpfeastol, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPdualfeastol(scip) - ccall((:SCIPdualfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPdualfeastol, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPbarrierconvtol(scip) - ccall((:SCIPbarrierconvtol, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPbarrierconvtol, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPcutoffbounddelta(scip) - ccall((:SCIPcutoffbounddelta, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPcutoffbounddelta, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPrelaxfeastol(scip) - ccall((:SCIPrelaxfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPrelaxfeastol, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPchgFeastol(scip, feastol) - ccall((:SCIPchgFeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, feastol) + ccall((:SCIPchgFeastol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, feastol) end function SCIPchgLpfeastol(scip, lpfeastol, printnewvalue) - ccall((:SCIPchgLpfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, UInt32), scip, lpfeastol, printnewvalue) + ccall((:SCIPchgLpfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble, UInt32), scip, lpfeastol, printnewvalue) end function SCIPchgDualfeastol(scip, dualfeastol) - ccall((:SCIPchgDualfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, dualfeastol) + ccall((:SCIPchgDualfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, dualfeastol) end function SCIPchgBarrierconvtol(scip, barrierconvtol) - ccall((:SCIPchgBarrierconvtol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, barrierconvtol) + ccall((:SCIPchgBarrierconvtol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, barrierconvtol) end function SCIPchgRelaxfeastol(scip, relaxfeastol) - ccall((:SCIPchgRelaxfeastol, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, relaxfeastol) + ccall((:SCIPchgRelaxfeastol, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, relaxfeastol) end function SCIPmarkLimitChanged(scip) - ccall((:SCIPmarkLimitChanged, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPmarkLimitChanged, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPinfinity(scip) - ccall((:SCIPinfinity, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPinfinity, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetHugeValue(scip) - ccall((:SCIPgetHugeValue, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetHugeValue, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPisEQ(scip, val1, val2) - ccall((:SCIPisEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisEQ, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisLT(scip, val1, val2) - ccall((:SCIPisLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisLT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisLE(scip, val1, val2) - ccall((:SCIPisLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisLE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisGT(scip, val1, val2) - ccall((:SCIPisGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisGT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisGE(scip, val1, val2) - ccall((:SCIPisGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisGE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisInfinity(scip, val) - ccall((:SCIPisInfinity, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisInfinity, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisHugeValue(scip, val) - ccall((:SCIPisHugeValue, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisHugeValue, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisZero(scip, val) - ccall((:SCIPisZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisZero, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisPositive(scip, val) - ccall((:SCIPisPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisPositive, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisNegative(scip, val) - ccall((:SCIPisNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisNegative, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisIntegral(scip, val) - ccall((:SCIPisIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisIntegral, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisScalingIntegral(scip, val, scalar) - ccall((:SCIPisScalingIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val, scalar) + ccall((:SCIPisScalingIntegral, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val, scalar) end function SCIPisFracIntegral(scip, val) - ccall((:SCIPisFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisFracIntegral, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPfloor(scip, val) - ccall((:SCIPfloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPfloor, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPceil(scip, val) - ccall((:SCIPceil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPceil, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPround(scip, val) - ccall((:SCIPround, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPround, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPfrac(scip, val) - ccall((:SCIPfrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPfrac, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisSumEQ(scip, val1, val2) - ccall((:SCIPisSumEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumEQ, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumLT(scip, val1, val2) - ccall((:SCIPisSumLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumLT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumLE(scip, val1, val2) - ccall((:SCIPisSumLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumLE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumGT(scip, val1, val2) - ccall((:SCIPisSumGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumGT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumGE(scip, val1, val2) - ccall((:SCIPisSumGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumGE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumZero(scip, val) - ccall((:SCIPisSumZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisSumZero, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisSumPositive(scip, val) - ccall((:SCIPisSumPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisSumPositive, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisSumNegative(scip, val) - ccall((:SCIPisSumNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisSumNegative, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisFeasEQ(scip, val1, val2) - ccall((:SCIPisFeasEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisFeasEQ, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasLT(scip, val1, val2) - ccall((:SCIPisFeasLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisFeasLT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasLE(scip, val1, val2) - ccall((:SCIPisFeasLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisFeasLE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasGT(scip, val1, val2) - ccall((:SCIPisFeasGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisFeasGT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasGE(scip, val1, val2) - ccall((:SCIPisFeasGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisFeasGE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasZero(scip, val) - ccall((:SCIPisFeasZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisFeasZero, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisFeasPositive(scip, val) - ccall((:SCIPisFeasPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisFeasPositive, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisFeasNegative(scip, val) - ccall((:SCIPisFeasNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisFeasNegative, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisFeasIntegral(scip, val) - ccall((:SCIPisFeasIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisFeasIntegral, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisFeasFracIntegral(scip, val) - ccall((:SCIPisFeasFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisFeasFracIntegral, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPfeasFloor(scip, val) - ccall((:SCIPfeasFloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPfeasFloor, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPfeasCeil(scip, val) - ccall((:SCIPfeasCeil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPfeasCeil, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPfeasRound(scip, val) - ccall((:SCIPfeasRound, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPfeasRound, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPfeasFrac(scip, val) - ccall((:SCIPfeasFrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPfeasFrac, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisDualfeasEQ(scip, val1, val2) - ccall((:SCIPisDualfeasEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisDualfeasEQ, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasLT(scip, val1, val2) - ccall((:SCIPisDualfeasLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisDualfeasLT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasLE(scip, val1, val2) - ccall((:SCIPisDualfeasLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisDualfeasLE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasGT(scip, val1, val2) - ccall((:SCIPisDualfeasGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisDualfeasGT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasGE(scip, val1, val2) - ccall((:SCIPisDualfeasGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisDualfeasGE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasZero(scip, val) - ccall((:SCIPisDualfeasZero, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisDualfeasZero, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisDualfeasPositive(scip, val) - ccall((:SCIPisDualfeasPositive, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisDualfeasPositive, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisDualfeasNegative(scip, val) - ccall((:SCIPisDualfeasNegative, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisDualfeasNegative, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisDualfeasIntegral(scip, val) - ccall((:SCIPisDualfeasIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisDualfeasIntegral, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisDualfeasFracIntegral(scip, val) - ccall((:SCIPisDualfeasFracIntegral, libscip), UInt32, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPisDualfeasFracIntegral, libscip), UInt32, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPdualfeasFloor(scip, val) - ccall((:SCIPdualfeasFloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPdualfeasFloor, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPdualfeasCeil(scip, val) - ccall((:SCIPdualfeasCeil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPdualfeasCeil, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPdualfeasRound(scip, val) - ccall((:SCIPdualfeasRound, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPdualfeasRound, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPdualfeasFrac(scip, val) - ccall((:SCIPdualfeasFrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall((:SCIPdualfeasFrac, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, val) end function SCIPisLbBetter(scip, newlb, oldlb, oldub) - ccall((:SCIPisLbBetter, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newlb, oldlb, oldub) + ccall((:SCIPisLbBetter, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble), scip, newlb, oldlb, oldub) end function SCIPisUbBetter(scip, newub, oldlb, oldub) - ccall((:SCIPisUbBetter, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newub, oldlb, oldub) + ccall((:SCIPisUbBetter, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble), scip, newub, oldlb, oldub) end function SCIPisRelEQ(scip, val1, val2) - ccall((:SCIPisRelEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisRelEQ, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisRelLT(scip, val1, val2) - ccall((:SCIPisRelLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisRelLT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisRelLE(scip, val1, val2) - ccall((:SCIPisRelLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisRelLE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisRelGT(scip, val1, val2) - ccall((:SCIPisRelGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisRelGT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisRelGE(scip, val1, val2) - ccall((:SCIPisRelGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisRelGE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelEQ(scip, val1, val2) - ccall((:SCIPisSumRelEQ, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumRelEQ, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelLT(scip, val1, val2) - ccall((:SCIPisSumRelLT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumRelLT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelLE(scip, val1, val2) - ccall((:SCIPisSumRelLE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumRelLE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelGT(scip, val1, val2) - ccall((:SCIPisSumRelGT, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumRelGT, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelGE(scip, val1, val2) - ccall((:SCIPisSumRelGE, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall((:SCIPisSumRelGE, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, val1, val2) end function SCIPconvertRealToInt(scip, real) - ccall((:SCIPconvertRealToInt, libscip), Cint, (Ptr{SCIP}, Cdouble), scip, real) + ccall((:SCIPconvertRealToInt, libscip), Cint, (Ptr{SCIP_}, Cdouble), scip, real) end function SCIPconvertRealToLongint(scip, real) - ccall((:SCIPconvertRealToLongint, libscip), Clonglong, (Ptr{SCIP}, Cdouble), scip, real) + ccall((:SCIPconvertRealToLongint, libscip), Clonglong, (Ptr{SCIP_}, Cdouble), scip, real) end function SCIPisUpdateUnreliable(scip, newvalue, oldvalue) - ccall((:SCIPisUpdateUnreliable, libscip), UInt32, (Ptr{SCIP}, Cdouble, Cdouble), scip, newvalue, oldvalue) + ccall((:SCIPisUpdateUnreliable, libscip), UInt32, (Ptr{SCIP_}, Cdouble, Cdouble), scip, newvalue, oldvalue) end function SCIPprintReal(scip, file, val, width, precision) - ccall((:SCIPprintReal, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}, Cdouble, Cint, Cint), scip, file, val, width, precision) + ccall((:SCIPprintReal, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}, Cdouble, Cint, Cint), scip, file, val, width, precision) end function SCIPparseReal(scip, str, value, endptr) - ccall((:SCIPparseReal, libscip), UInt32, (Ptr{SCIP}, Cstring, Ptr{Cdouble}, Ptr{Cstring}), scip, str, value, endptr) + ccall((:SCIPparseReal, libscip), UInt32, (Ptr{SCIP_}, Cstring, Ptr{Cdouble}, Ptr{Cstring}), scip, str, value, endptr) end diff --git a/src/wrapper/scip_param.jl b/src/wrapper/scip_param.jl index 2093e1da..d958a552 100644 --- a/src/wrapper/scip_param.jl +++ b/src/wrapper/scip_param.jl @@ -3,189 +3,189 @@ function SCIPaddBoolParam(scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) - ccall((:SCIPaddBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{UInt32}, UInt32, UInt32, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) + ccall((:SCIPaddBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Ptr{UInt32}, UInt32, UInt32, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) end function SCIPaddIntParam(scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) - ccall((:SCIPaddIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cint}, UInt32, Cint, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) + ccall((:SCIPaddIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Ptr{Cint}, UInt32, Cint, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end function SCIPaddLongintParam(scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) - ccall((:SCIPaddLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Clonglong}, UInt32, Clonglong, Clonglong, Clonglong, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) + ccall((:SCIPaddLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Ptr{Clonglong}, UInt32, Clonglong, Clonglong, Clonglong, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end function SCIPaddRealParam(scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) - ccall((:SCIPaddRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cdouble}, UInt32, Cdouble, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) + ccall((:SCIPaddRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Ptr{Cdouble}, UInt32, Cdouble, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end function SCIPaddCharParam(scip, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) - ccall((:SCIPaddCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cstring, UInt32, UInt8, Cstring, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) + ccall((:SCIPaddCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cstring, UInt32, UInt8, Cstring, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) end function SCIPaddStringParam(scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) - ccall((:SCIPaddStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Ptr{Cstring}, UInt32, Cstring, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) + ccall((:SCIPaddStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Ptr{Cstring}, UInt32, Cstring, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) end function SCIPisParamFixed(scip, name) - ccall((:SCIPisParamFixed, libscip), UInt32, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPisParamFixed, libscip), UInt32, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetParam(scip, name) - ccall((:SCIPgetParam, libscip), Ptr{SCIP_PARAM}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPgetParam, libscip), Ptr{SCIP_PARAM}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetBoolParam(scip, name, value) - ccall((:SCIPgetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{UInt32}), scip, name, value) + ccall((:SCIPgetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{UInt32}), scip, name, value) end function SCIPgetIntParam(scip, name, value) - ccall((:SCIPgetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cint}), scip, name, value) + ccall((:SCIPgetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Cint}), scip, name, value) end function SCIPgetLongintParam(scip, name, value) - ccall((:SCIPgetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Clonglong}), scip, name, value) + ccall((:SCIPgetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Clonglong}), scip, name, value) end function SCIPgetRealParam(scip, name, value) - ccall((:SCIPgetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cdouble}), scip, name, value) + ccall((:SCIPgetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Cdouble}), scip, name, value) end function SCIPgetCharParam(scip, name, value) - ccall((:SCIPgetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, name, value) + ccall((:SCIPgetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring), scip, name, value) end function SCIPgetStringParam(scip, name, value) - ccall((:SCIPgetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cstring}), scip, name, value) + ccall((:SCIPgetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Cstring}), scip, name, value) end function SCIPfixParam(scip, name) - ccall((:SCIPfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPunfixParam(scip, name) - ccall((:SCIPunfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPunfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPsetParam(scip, name, value) - ccall((:SCIPsetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cvoid}), scip, name, value) + ccall((:SCIPsetParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Cvoid}), scip, name, value) end function SCIPchgBoolParam(scip, param, value) - ccall((:SCIPchgBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt32), scip, param, value) + ccall((:SCIPchgBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, UInt32), scip, param, value) end function SCIPsetBoolParam(scip, name, value) - ccall((:SCIPsetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32), scip, name, value) + ccall((:SCIPsetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, UInt32), scip, name, value) end function SCIPisBoolParamValid(scip, param, value) - ccall((:SCIPisBoolParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt32), scip, param, value) + ccall((:SCIPisBoolParamValid, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, UInt32), scip, param, value) end function SCIPchgIntParam(scip, param, value) - ccall((:SCIPchgIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) + ccall((:SCIPchgIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Cint), scip, param, value) end function SCIPsetIntParam(scip, name, value) - ccall((:SCIPsetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cint), scip, name, value) + ccall((:SCIPsetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cint), scip, name, value) end function SCIPisIntParamValid(scip, param, value) - ccall((:SCIPisIntParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) + ccall((:SCIPisIntParamValid, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Cint), scip, param, value) end function SCIPchgLongintParam(scip, param, value) - ccall((:SCIPchgLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) + ccall((:SCIPchgLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) end function SCIPsetLongintParam(scip, name, value) - ccall((:SCIPsetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Clonglong), scip, name, value) + ccall((:SCIPsetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Clonglong), scip, name, value) end function SCIPisLongintParamValid(scip, param, value) - ccall((:SCIPisLongintParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) + ccall((:SCIPisLongintParamValid, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) end function SCIPchgRealParam(scip, param, value) - ccall((:SCIPchgRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) + ccall((:SCIPchgRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) end function SCIPsetRealParam(scip, name, value) - ccall((:SCIPsetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cdouble), scip, name, value) + ccall((:SCIPsetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cdouble), scip, name, value) end function SCIPisRealParamValid(scip, param, value) - ccall((:SCIPisRealParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) + ccall((:SCIPisRealParamValid, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) end function SCIPchgCharParam(scip, param, value) - ccall((:SCIPchgCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt8), scip, param, value) + ccall((:SCIPchgCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, UInt8), scip, param, value) end function SCIPsetCharParam(scip, name, value) - ccall((:SCIPsetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt8), scip, name, value) + ccall((:SCIPsetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, UInt8), scip, name, value) end function SCIPisCharParamValid(scip, param, value) - ccall((:SCIPisCharParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, UInt8), scip, param, value) + ccall((:SCIPisCharParamValid, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, UInt8), scip, param, value) end function SCIPchgStringParam(scip, param, value) - ccall((:SCIPchgStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cstring), scip, param, value) + ccall((:SCIPchgStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Cstring), scip, param, value) end function SCIPsetStringParam(scip, name, value) - ccall((:SCIPsetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, name, value) + ccall((:SCIPsetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring), scip, name, value) end function SCIPisStringParamValid(scip, param, value) - ccall((:SCIPisStringParamValid, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cstring), scip, param, value) + ccall((:SCIPisStringParamValid, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Cstring), scip, param, value) end function SCIPreadParams(scip, filename) - ccall((:SCIPreadParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) + ccall((:SCIPreadParams, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, filename) end function SCIPwriteParam(scip, param, filename, comments, onlychanged) - ccall((:SCIPwriteParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cstring, UInt32, UInt32), scip, param, filename, comments, onlychanged) + ccall((:SCIPwriteParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PARAM}, Cstring, UInt32, UInt32), scip, param, filename, comments, onlychanged) end function SCIPwriteParams(scip, filename, comments, onlychanged) - ccall((:SCIPwriteParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32, UInt32), scip, filename, comments, onlychanged) + ccall((:SCIPwriteParams, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, UInt32, UInt32), scip, filename, comments, onlychanged) end function SCIPresetParam(scip, name) - ccall((:SCIPresetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPresetParam, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPresetParams(scip) - ccall((:SCIPresetParams, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPresetParams, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPsetEmphasis(scip, paramemphasis, quiet) - ccall((:SCIPsetEmphasis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMEMPHASIS, UInt32), scip, paramemphasis, quiet) + ccall((:SCIPsetEmphasis, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_PARAMEMPHASIS, UInt32), scip, paramemphasis, quiet) end function SCIPsetSubscipsOff(scip, quiet) - ccall((:SCIPsetSubscipsOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, quiet) + ccall((:SCIPsetSubscipsOff, libscip), SCIP_RETCODE, (Ptr{SCIP_}, UInt32), scip, quiet) end function SCIPsetHeuristics(scip, paramsetting, quiet) - ccall((:SCIPsetHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) + ccall((:SCIPsetHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) end function SCIPsetPresolving(scip, paramsetting, quiet) - ccall((:SCIPsetPresolving, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) + ccall((:SCIPsetPresolving, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) end function SCIPsetSeparating(scip, paramsetting, quiet) - ccall((:SCIPsetSeparating, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) + ccall((:SCIPsetSeparating, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_PARAMSETTING, UInt32), scip, paramsetting, quiet) end function SCIPgetParams(scip) - ccall((:SCIPgetParams, libscip), Ptr{Ptr{SCIP_PARAM}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetParams, libscip), Ptr{Ptr{SCIP_PARAM}}, (Ptr{SCIP_},), scip) end function SCIPgetNParams(scip) - ccall((:SCIPgetNParams, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNParams, libscip), Cint, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_presol.jl b/src/wrapper/scip_presol.jl index bda0b512..693c95f2 100644 --- a/src/wrapper/scip_presol.jl +++ b/src/wrapper/scip_presol.jl @@ -3,49 +3,49 @@ function SCIPincludePresol(scip, name, desc, priority, maxrounds, timing, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) - ccall((:SCIPincludePresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, name, desc, priority, maxrounds, timing, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) + ccall((:SCIPincludePresol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, name, desc, priority, maxrounds, timing, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) end function SCIPincludePresolBasic(scip, presolptr, name, desc, priority, maxrounds, timing, presolexec, presoldata) - ccall((:SCIPincludePresolBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PRESOL}}, Cstring, Cstring, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, presolptr, name, desc, priority, maxrounds, timing, presolexec, presoldata) + ccall((:SCIPincludePresolBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_PRESOL}}, Cstring, Cstring, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, presolptr, name, desc, priority, maxrounds, timing, presolexec, presoldata) end function SCIPsetPresolCopy(scip, presol, presolcopy) - ccall((:SCIPsetPresolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolcopy) + ccall((:SCIPsetPresolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolcopy) end function SCIPsetPresolFree(scip, presol, presolfree) - ccall((:SCIPsetPresolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolfree) + ccall((:SCIPsetPresolFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolfree) end function SCIPsetPresolInit(scip, presol, presolinit) - ccall((:SCIPsetPresolInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinit) + ccall((:SCIPsetPresolInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinit) end function SCIPsetPresolExit(scip, presol, presolexit) - ccall((:SCIPsetPresolExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexit) + ccall((:SCIPsetPresolExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexit) end function SCIPsetPresolInitpre(scip, presol, presolinitpre) - ccall((:SCIPsetPresolInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinitpre) + ccall((:SCIPsetPresolInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinitpre) end function SCIPsetPresolExitpre(scip, presol, presolexitpre) - ccall((:SCIPsetPresolExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexitpre) + ccall((:SCIPsetPresolExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexitpre) end function SCIPfindPresol(scip, name) - ccall((:SCIPfindPresol, libscip), Ptr{SCIP_PRESOL}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindPresol, libscip), Ptr{SCIP_PRESOL}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetPresols(scip) - ccall((:SCIPgetPresols, libscip), Ptr{Ptr{SCIP_PRESOL}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetPresols, libscip), Ptr{Ptr{SCIP_PRESOL}}, (Ptr{SCIP_},), scip) end function SCIPgetNPresols(scip) - ccall((:SCIPgetNPresols, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPresols, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetPresolPriority(scip, presol, priority) - ccall((:SCIPsetPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Cint), scip, presol, priority) + ccall((:SCIPsetPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRESOL}, Cint), scip, presol, priority) end diff --git a/src/wrapper/scip_pricer.jl b/src/wrapper/scip_pricer.jl index 5fa0ef77..6e07a773 100644 --- a/src/wrapper/scip_pricer.jl +++ b/src/wrapper/scip_pricer.jl @@ -3,61 +3,61 @@ function SCIPincludePricer(scip, name, desc, priority, delay, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) - ccall((:SCIPincludePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, name, desc, priority, delay, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) + ccall((:SCIPincludePricer, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, name, desc, priority, delay, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) end function SCIPincludePricerBasic(scip, pricerptr, name, desc, priority, delay, pricerredcost, pricerfarkas, pricerdata) - ccall((:SCIPincludePricerBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PRICER}}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, pricerptr, name, desc, priority, delay, pricerredcost, pricerfarkas, pricerdata) + ccall((:SCIPincludePricerBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_PRICER}}, Cstring, Cstring, Cint, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, pricerptr, name, desc, priority, delay, pricerredcost, pricerfarkas, pricerdata) end function SCIPsetPricerCopy(scip, pricer, pricercopy) - ccall((:SCIPsetPricerCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricercopy) + ccall((:SCIPsetPricerCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricercopy) end function SCIPsetPricerFree(scip, pricer, pricerfree) - ccall((:SCIPsetPricerFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerfree) + ccall((:SCIPsetPricerFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerfree) end function SCIPsetPricerInit(scip, pricer, pricerinit) - ccall((:SCIPsetPricerInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinit) + ccall((:SCIPsetPricerInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinit) end function SCIPsetPricerExit(scip, pricer, pricerexit) - ccall((:SCIPsetPricerExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexit) + ccall((:SCIPsetPricerExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexit) end function SCIPsetPricerInitsol(scip, pricer, pricerinitsol) - ccall((:SCIPsetPricerInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinitsol) + ccall((:SCIPsetPricerInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinitsol) end function SCIPsetPricerExitsol(scip, pricer, pricerexitsol) - ccall((:SCIPsetPricerExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexitsol) + ccall((:SCIPsetPricerExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexitsol) end function SCIPfindPricer(scip, name) - ccall((:SCIPfindPricer, libscip), Ptr{SCIP_PRICER}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindPricer, libscip), Ptr{SCIP_PRICER}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetPricers(scip) - ccall((:SCIPgetPricers, libscip), Ptr{Ptr{SCIP_PRICER}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetPricers, libscip), Ptr{Ptr{SCIP_PRICER}}, (Ptr{SCIP_},), scip) end function SCIPgetNPricers(scip) - ccall((:SCIPgetNPricers, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPricers, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNActivePricers(scip) - ccall((:SCIPgetNActivePricers, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNActivePricers, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetPricerPriority(scip, pricer, priority) - ccall((:SCIPsetPricerPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Cint), scip, pricer, priority) + ccall((:SCIPsetPricerPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}, Cint), scip, pricer, priority) end function SCIPactivatePricer(scip, pricer) - ccall((:SCIPactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}), scip, pricer) + ccall((:SCIPactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}), scip, pricer) end function SCIPdeactivatePricer(scip, pricer) - ccall((:SCIPdeactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}), scip, pricer) + ccall((:SCIPdeactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PRICER}), scip, pricer) end diff --git a/src/wrapper/scip_prob.jl b/src/wrapper/scip_prob.jl index c07736d8..41142d35 100644 --- a/src/wrapper/scip_prob.jl +++ b/src/wrapper/scip_prob.jl @@ -3,329 +3,329 @@ function SCIPcreateProb(scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) - ccall((:SCIPcreateProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PROBDATA}), scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) + ccall((:SCIPcreateProb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PROBDATA}), scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) end function SCIPcreateProbBasic(scip, name) - ccall((:SCIPcreateProbBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPcreateProbBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPsetProbDelorig(scip, probdelorig) - ccall((:SCIPsetProbDelorig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probdelorig) + ccall((:SCIPsetProbDelorig, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}), scip, probdelorig) end function SCIPsetProbTrans(scip, probtrans) - ccall((:SCIPsetProbTrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probtrans) + ccall((:SCIPsetProbTrans, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}), scip, probtrans) end function SCIPsetProbDeltrans(scip, probdeltrans) - ccall((:SCIPsetProbDeltrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probdeltrans) + ccall((:SCIPsetProbDeltrans, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}), scip, probdeltrans) end function SCIPsetProbInitsol(scip, probinitsol) - ccall((:SCIPsetProbInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probinitsol) + ccall((:SCIPsetProbInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}), scip, probinitsol) end function SCIPsetProbExitsol(scip, probexitsol) - ccall((:SCIPsetProbExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probexitsol) + ccall((:SCIPsetProbExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}), scip, probexitsol) end function SCIPsetProbCopy(scip, probcopy) - ccall((:SCIPsetProbCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probcopy) + ccall((:SCIPsetProbCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cvoid}), scip, probcopy) end function SCIPreadProb(scip, filename, extension) - ccall((:SCIPreadProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring), scip, filename, extension) + ccall((:SCIPreadProb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring), scip, filename, extension) end function SCIPwriteOrigProblem(scip, filename, extension, genericnames) - ccall((:SCIPwriteOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32), scip, filename, extension, genericnames) + ccall((:SCIPwriteOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, UInt32), scip, filename, extension, genericnames) end function SCIPwriteTransProblem(scip, filename, extension, genericnames) - ccall((:SCIPwriteTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32), scip, filename, extension, genericnames) + ccall((:SCIPwriteTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, UInt32), scip, filename, extension, genericnames) end function SCIPfreeProb(scip) - ccall((:SCIPfreeProb, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPfreeProb, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPpermuteProb(scip, randseed, permuteconss, permutebinvars, permuteintvars, permuteimplvars, permutecontvars) - ccall((:SCIPpermuteProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, randseed, permuteconss, permutebinvars, permuteintvars, permuteimplvars, permutecontvars) + ccall((:SCIPpermuteProb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32), scip, randseed, permuteconss, permutebinvars, permuteintvars, permuteimplvars, permutecontvars) end function SCIPgetProbData(scip) - ccall((:SCIPgetProbData, libscip), Ptr{SCIP_PROBDATA}, (Ptr{SCIP},), scip) + ccall((:SCIPgetProbData, libscip), Ptr{SCIP_PROBDATA}, (Ptr{SCIP_},), scip) end function SCIPsetProbData(scip, probdata) - ccall((:SCIPsetProbData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROBDATA}), scip, probdata) + ccall((:SCIPsetProbData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROBDATA}), scip, probdata) end function SCIPgetProbName(scip) - ccall((:SCIPgetProbName, libscip), Cstring, (Ptr{SCIP},), scip) + ccall((:SCIPgetProbName, libscip), Cstring, (Ptr{SCIP_},), scip) end function SCIPsetProbName(scip, name) - ccall((:SCIPsetProbName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPsetProbName, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPchgReoptObjective(scip, objsense, vars, coefs, nvars) - ccall((:SCIPchgReoptObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), scip, objsense, vars, coefs, nvars) + ccall((:SCIPchgReoptObjective, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_OBJSENSE, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), scip, objsense, vars, coefs, nvars) end function SCIPgetObjsense(scip) - ccall((:SCIPgetObjsense, libscip), SCIP_OBJSENSE, (Ptr{SCIP},), scip) + ccall((:SCIPgetObjsense, libscip), SCIP_OBJSENSE, (Ptr{SCIP_},), scip) end function SCIPsetObjsense(scip, objsense) - ccall((:SCIPsetObjsense, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE), scip, objsense) + ccall((:SCIPsetObjsense, libscip), SCIP_RETCODE, (Ptr{SCIP_}, SCIP_OBJSENSE), scip, objsense) end function SCIPaddObjoffset(scip, addval) - ccall((:SCIPaddObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) + ccall((:SCIPaddObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, addval) end function SCIPaddOrigObjoffset(scip, addval) - ccall((:SCIPaddOrigObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) + ccall((:SCIPaddOrigObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, addval) end function SCIPgetOrigObjoffset(scip) - ccall((:SCIPgetOrigObjoffset, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetOrigObjoffset, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetOrigObjscale(scip) - ccall((:SCIPgetOrigObjscale, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetOrigObjscale, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetTransObjoffset(scip) - ccall((:SCIPgetTransObjoffset, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetTransObjoffset, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetTransObjscale(scip) - ccall((:SCIPgetTransObjscale, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetTransObjscale, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPsetObjlimit(scip, objlimit) - ccall((:SCIPsetObjlimit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, objlimit) + ccall((:SCIPsetObjlimit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, objlimit) end function SCIPgetObjlimit(scip) - ccall((:SCIPgetObjlimit, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetObjlimit, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPsetObjIntegral(scip) - ccall((:SCIPsetObjIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPsetObjIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPisObjIntegral(scip) - ccall((:SCIPisObjIntegral, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisObjIntegral, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetObjNorm(scip) - ccall((:SCIPgetObjNorm, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetObjNorm, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPaddVar(scip, var) - ccall((:SCIPaddVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPaddVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPaddPricedVar(scip, var, score) - ccall((:SCIPaddPricedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, score) + ccall((:SCIPaddPricedVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, score) end function SCIPdelVar(scip, var, deleted) - ccall((:SCIPdelVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{UInt32}), scip, var, deleted) + ccall((:SCIPdelVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{UInt32}), scip, var, deleted) end function SCIPgetVarsData(scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) - ccall((:SCIPgetVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) + ccall((:SCIPgetVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) end function SCIPgetVars(scip) - ccall((:SCIPgetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_},), scip) end function SCIPgetNVars(scip) - ccall((:SCIPgetNVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNBinVars(scip) - ccall((:SCIPgetNBinVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNBinVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNIntVars(scip) - ccall((:SCIPgetNIntVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNIntVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNImplVars(scip) - ccall((:SCIPgetNImplVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNImplVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNContVars(scip) - ccall((:SCIPgetNContVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNContVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNObjVars(scip) - ccall((:SCIPgetNObjVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNObjVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetFixedVars(scip) - ccall((:SCIPgetFixedVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetFixedVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_},), scip) end function SCIPgetNFixedVars(scip) - ccall((:SCIPgetNFixedVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNFixedVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetOrigVarsData(scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) - ccall((:SCIPgetOrigVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) + ccall((:SCIPgetOrigVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) end function SCIPgetOrigVars(scip) - ccall((:SCIPgetOrigVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetOrigVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_},), scip) end function SCIPgetNOrigVars(scip) - ccall((:SCIPgetNOrigVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNOrigVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNOrigBinVars(scip) - ccall((:SCIPgetNOrigBinVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNOrigBinVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNOrigIntVars(scip) - ccall((:SCIPgetNOrigIntVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNOrigIntVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNOrigImplVars(scip) - ccall((:SCIPgetNOrigImplVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNOrigImplVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNOrigContVars(scip) - ccall((:SCIPgetNOrigContVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNOrigContVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNTotalVars(scip) - ccall((:SCIPgetNTotalVars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNTotalVars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetSolVarsData(scip, sol, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) - ccall((:SCIPgetSolVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, sol, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) + ccall((:SCIPgetSolVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, sol, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) end function SCIPfindVar(scip, name) - ccall((:SCIPfindVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPallVarsInProb(scip) - ccall((:SCIPallVarsInProb, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPallVarsInProb, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPaddCons(scip, cons) - ccall((:SCIPaddCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPaddCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdelCons(scip, cons) - ccall((:SCIPdelCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPdelCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPfindOrigCons(scip, name) - ccall((:SCIPfindOrigCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindOrigCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPfindCons(scip, name) - ccall((:SCIPfindCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetNUpgrConss(scip) - ccall((:SCIPgetNUpgrConss, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNUpgrConss, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNConss(scip) - ccall((:SCIPgetNConss, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNConss, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetConss(scip) - ccall((:SCIPgetConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP_},), scip) end function SCIPgetNOrigConss(scip) - ccall((:SCIPgetNOrigConss, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNOrigConss, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetOrigConss(scip) - ccall((:SCIPgetOrigConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetOrigConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP_},), scip) end function SCIPgetNCheckConss(scip) - ccall((:SCIPgetNCheckConss, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNCheckConss, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPaddConflict(scip, node, cons, validnode, conftype, iscutoffinvolved) - ccall((:SCIPaddConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}, SCIP_CONFTYPE, UInt32), scip, node, cons, validnode, conftype, iscutoffinvolved) + ccall((:SCIPaddConflict, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}, SCIP_CONFTYPE, UInt32), scip, node, cons, validnode, conftype, iscutoffinvolved) end function SCIPclearConflictStore(scip, event) - ccall((:SCIPclearConflictStore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENT}), scip, event) + ccall((:SCIPclearConflictStore, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_EVENT}), scip, event) end function SCIPaddConsNode(scip, node, cons, validnode) - ccall((:SCIPaddConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, node, cons, validnode) + ccall((:SCIPaddConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, node, cons, validnode) end function SCIPaddConsLocal(scip, cons, validnode) - ccall((:SCIPaddConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, cons, validnode) + ccall((:SCIPaddConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, cons, validnode) end function SCIPdelConsNode(scip, node, cons) - ccall((:SCIPdelConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}), scip, node, cons) + ccall((:SCIPdelConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}), scip, node, cons) end function SCIPdelConsLocal(scip, cons) - ccall((:SCIPdelConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall((:SCIPdelConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) end function SCIPgetLocalOrigEstimate(scip) - ccall((:SCIPgetLocalOrigEstimate, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLocalOrigEstimate, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLocalTransEstimate(scip) - ccall((:SCIPgetLocalTransEstimate, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLocalTransEstimate, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLocalDualbound(scip) - ccall((:SCIPgetLocalDualbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLocalDualbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLocalLowerbound(scip) - ccall((:SCIPgetLocalLowerbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLocalLowerbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetNodeDualbound(scip, node) - ccall((:SCIPgetNodeDualbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall((:SCIPgetNodeDualbound, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_NODE}), scip, node) end function SCIPgetNodeLowerbound(scip, node) - ccall((:SCIPgetNodeLowerbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall((:SCIPgetNodeLowerbound, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_NODE}), scip, node) end function SCIPupdateLocalDualbound(scip, newbound) - ccall((:SCIPupdateLocalDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) + ccall((:SCIPupdateLocalDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, newbound) end function SCIPupdateLocalLowerbound(scip, newbound) - ccall((:SCIPupdateLocalLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) + ccall((:SCIPupdateLocalLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, newbound) end function SCIPupdateNodeDualbound(scip, node, newbound) - ccall((:SCIPupdateNodeDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) + ccall((:SCIPupdateNodeDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) end function SCIPupdateNodeLowerbound(scip, node, newbound) - ccall((:SCIPupdateNodeLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) + ccall((:SCIPupdateNodeLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) end function SCIPchgChildPrio(scip, child, priority) - ccall((:SCIPchgChildPrio, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, child, priority) + ccall((:SCIPchgChildPrio, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Cdouble), scip, child, priority) end diff --git a/src/wrapper/scip_probing.jl b/src/wrapper/scip_probing.jl index eca9b651..30dc4942 100644 --- a/src/wrapper/scip_probing.jl +++ b/src/wrapper/scip_probing.jl @@ -3,109 +3,109 @@ function SCIPinProbing(scip) - ccall((:SCIPinProbing, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPinProbing, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPstartProbing(scip) - ccall((:SCIPstartProbing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPstartProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPnewProbingNode(scip) - ccall((:SCIPnewProbingNode, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPnewProbingNode, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPgetProbingDepth(scip) - ccall((:SCIPgetProbingDepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetProbingDepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPbacktrackProbing(scip, probingdepth) - ccall((:SCIPbacktrackProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint), scip, probingdepth) + ccall((:SCIPbacktrackProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint), scip, probingdepth) end function SCIPendProbing(scip) - ccall((:SCIPendProbing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPendProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPchgVarLbProbing(scip, var, newbound) - ccall((:SCIPchgVarLbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall((:SCIPchgVarLbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarUbProbing(scip, var, newbound) - ccall((:SCIPchgVarUbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall((:SCIPchgVarUbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPgetVarObjProbing(scip, var) - ccall((:SCIPgetVarObjProbing, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarObjProbing, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPfixVarProbing(scip, var, fixedval) - ccall((:SCIPfixVarProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, fixedval) + ccall((:SCIPfixVarProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, fixedval) end function SCIPchgVarObjProbing(scip, var, newobj) - ccall((:SCIPchgVarObjProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) + ccall((:SCIPchgVarObjProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end function SCIPisObjChangedProbing(scip) - ccall((:SCIPisObjChangedProbing, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisObjChangedProbing, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPpropagateProbing(scip, maxproprounds, cutoff, ndomredsfound) - ccall((:SCIPpropagateProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{Clonglong}), scip, maxproprounds, cutoff, ndomredsfound) + ccall((:SCIPpropagateProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{UInt32}, Ptr{Clonglong}), scip, maxproprounds, cutoff, ndomredsfound) end function SCIPpropagateProbingImplications(scip, cutoff) - ccall((:SCIPpropagateProbingImplications, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) + ccall((:SCIPpropagateProbingImplications, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{UInt32}), scip, cutoff) end function SCIPsolveProbingLP(scip, itlim, lperror, cutoff) - ccall((:SCIPsolveProbingLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, itlim, lperror, cutoff) + ccall((:SCIPsolveProbingLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, itlim, lperror, cutoff) end function SCIPsolveProbingLPWithPricing(scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) - ccall((:SCIPsolveProbingLPWithPricing, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32, UInt32, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) + ccall((:SCIPsolveProbingLPWithPricing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, UInt32, UInt32, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) end function SCIPsetProbingLPState(scip, lpistate, lpinorms, primalfeas, dualfeas) - ccall((:SCIPsetProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LPISTATE}}, Ptr{Ptr{SCIP_LPINORMS}}, UInt32, UInt32), scip, lpistate, lpinorms, primalfeas, dualfeas) + ccall((:SCIPsetProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_LPISTATE}}, Ptr{Ptr{SCIP_LPINORMS}}, UInt32, UInt32), scip, lpistate, lpinorms, primalfeas, dualfeas) end function SCIPaddRowProbing(scip, row) - ccall((:SCIPaddRowProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall((:SCIPaddRowProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_ROW}), scip, row) end function SCIPapplyCutsProbing(scip, cutoff) - ccall((:SCIPapplyCutsProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) + ccall((:SCIPapplyCutsProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{UInt32}), scip, cutoff) end function SCIPsolveProbingRelax(scip, cutoff) - ccall((:SCIPsolveProbingRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, cutoff) + ccall((:SCIPsolveProbingRelax, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{UInt32}), scip, cutoff) end function SCIPgetDivesetScore(scip, diveset, divetype, divecand, divecandsol, divecandfrac, candscore, roundup) - ccall((:SCIPgetDivesetScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, SCIP_DIVETYPE, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{UInt32}), scip, diveset, divetype, divecand, divecandsol, divecandfrac, candscore, roundup) + ccall((:SCIPgetDivesetScore, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIVESET}, SCIP_DIVETYPE, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{UInt32}), scip, diveset, divetype, divecand, divecandsol, divecandfrac, candscore, roundup) end function SCIPupdateDivesetLPStats(scip, diveset, niterstoadd) - ccall((:SCIPupdateDivesetLPStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Clonglong), scip, diveset, niterstoadd) + ccall((:SCIPupdateDivesetLPStats, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_DIVESET}, Clonglong), scip, diveset, niterstoadd) end function SCIPupdateDivesetStats(scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol) - ccall((:SCIPupdateDivesetStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Cint, Cint, Clonglong, Clonglong, Clonglong, UInt32), scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol) + ccall((:SCIPupdateDivesetStats, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_DIVESET}, Cint, Cint, Clonglong, Clonglong, Clonglong, UInt32), scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol) end function SCIPgetDiveBoundChanges(scip, diveset, sol, success, infeasible) - ccall((:SCIPgetDiveBoundChanges, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{UInt32}, Ptr{UInt32}), scip, diveset, sol, success, infeasible) + ccall((:SCIPgetDiveBoundChanges, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{UInt32}, Ptr{UInt32}), scip, diveset, sol, success, infeasible) end function SCIPaddDiveBoundChange(scip, var, dir, value, preferred) - ccall((:SCIPaddDiveBoundChange, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble, UInt32), scip, var, dir, value, preferred) + ccall((:SCIPaddDiveBoundChange, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble, UInt32), scip, var, dir, value, preferred) end function SCIPgetDiveBoundChangeData(scip, variables, directions, values, ndivebdchgs, preferred) - ccall((:SCIPgetDiveBoundChangeData, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{SCIP_BRANCHDIR}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, UInt32), scip, variables, directions, values, ndivebdchgs, preferred) + ccall((:SCIPgetDiveBoundChangeData, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{SCIP_BRANCHDIR}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, UInt32), scip, variables, directions, values, ndivebdchgs, preferred) end function SCIPclearDiveBoundChanges(scip) - ccall((:SCIPclearDiveBoundChanges, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPclearDiveBoundChanges, libscip), Cvoid, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_prop.jl b/src/wrapper/scip_prop.jl index 7e031a6f..0cebec76 100644 --- a/src/wrapper/scip_prop.jl +++ b/src/wrapper/scip_prop.jl @@ -3,69 +3,69 @@ function SCIPincludeProp(scip, name, desc, priority, freq, delay, timingmask, presolpriority, presolmaxrounds, presoltiming, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) - ccall((:SCIPincludeProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, UInt32, SCIP_PROPTIMING, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, name, desc, priority, freq, delay, timingmask, presolpriority, presolmaxrounds, presoltiming, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) + ccall((:SCIPincludeProp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Cint, UInt32, SCIP_PROPTIMING, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, name, desc, priority, freq, delay, timingmask, presolpriority, presolmaxrounds, presoltiming, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) end function SCIPincludePropBasic(scip, propptr, name, desc, priority, freq, delay, timingmask, propexec, propdata) - ccall((:SCIPincludePropBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PROP}}, Cstring, Cstring, Cint, Cint, UInt32, SCIP_PROPTIMING, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, propptr, name, desc, priority, freq, delay, timingmask, propexec, propdata) + ccall((:SCIPincludePropBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_PROP}}, Cstring, Cstring, Cint, Cint, UInt32, SCIP_PROPTIMING, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, propptr, name, desc, priority, freq, delay, timingmask, propexec, propdata) end function SCIPsetPropCopy(scip, prop, propcopy) - ccall((:SCIPsetPropCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propcopy) + ccall((:SCIPsetPropCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propcopy) end function SCIPsetPropFree(scip, prop, propfree) - ccall((:SCIPsetPropFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propfree) + ccall((:SCIPsetPropFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propfree) end function SCIPsetPropInit(scip, prop, propinit) - ccall((:SCIPsetPropInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinit) + ccall((:SCIPsetPropInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinit) end function SCIPsetPropExit(scip, prop, propexit) - ccall((:SCIPsetPropExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexit) + ccall((:SCIPsetPropExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexit) end function SCIPsetPropInitsol(scip, prop, propinitsol) - ccall((:SCIPsetPropInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitsol) + ccall((:SCIPsetPropInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitsol) end function SCIPsetPropExitsol(scip, prop, propexitsol) - ccall((:SCIPsetPropExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitsol) + ccall((:SCIPsetPropExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitsol) end function SCIPsetPropInitpre(scip, prop, propinitpre) - ccall((:SCIPsetPropInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitpre) + ccall((:SCIPsetPropInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitpre) end function SCIPsetPropExitpre(scip, prop, propexitpre) - ccall((:SCIPsetPropExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitpre) + ccall((:SCIPsetPropExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitpre) end function SCIPsetPropPresol(scip, prop, proppresol, presolpriority, presolmaxrounds, presoltiming) - ccall((:SCIPsetPropPresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}, Cint, Cint, SCIP_PRESOLTIMING), scip, prop, proppresol, presolpriority, presolmaxrounds, presoltiming) + ccall((:SCIPsetPropPresol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}, Cint, Cint, SCIP_PRESOLTIMING), scip, prop, proppresol, presolpriority, presolmaxrounds, presoltiming) end function SCIPsetPropResprop(scip, prop, propresprop) - ccall((:SCIPsetPropResprop, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propresprop) + ccall((:SCIPsetPropResprop, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propresprop) end function SCIPfindProp(scip, name) - ccall((:SCIPfindProp, libscip), Ptr{SCIP_PROP}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindProp, libscip), Ptr{SCIP_PROP}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetProps(scip) - ccall((:SCIPgetProps, libscip), Ptr{Ptr{SCIP_PROP}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetProps, libscip), Ptr{Ptr{SCIP_PROP}}, (Ptr{SCIP_},), scip) end function SCIPgetNProps(scip) - ccall((:SCIPgetNProps, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNProps, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetPropPriority(scip, prop, priority) - ccall((:SCIPsetPropPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, priority) + ccall((:SCIPsetPropPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Cint), scip, prop, priority) end function SCIPsetPropPresolPriority(scip, prop, presolpriority) - ccall((:SCIPsetPropPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, presolpriority) + ccall((:SCIPsetPropPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_PROP}, Cint), scip, prop, presolpriority) end diff --git a/src/wrapper/scip_randnumgen.jl b/src/wrapper/scip_randnumgen.jl index f34ca688..6209360f 100644 --- a/src/wrapper/scip_randnumgen.jl +++ b/src/wrapper/scip_randnumgen.jl @@ -3,17 +3,17 @@ function SCIPcreateRandom(scip, randnumgen, initialseed, useglobalseed) - ccall((:SCIPcreateRandom, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}, UInt32, UInt32), scip, randnumgen, initialseed, useglobalseed) + ccall((:SCIPcreateRandom, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_RANDNUMGEN}}, UInt32, UInt32), scip, randnumgen, initialseed, useglobalseed) end function SCIPfreeRandom(scip, randnumgen) - ccall((:SCIPfreeRandom, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}), scip, randnumgen) + ccall((:SCIPfreeRandom, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Ptr{SCIP_RANDNUMGEN}}), scip, randnumgen) end function SCIPsetRandomSeed(scip, randnumgen, seed) - ccall((:SCIPsetRandomSeed, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RANDNUMGEN}, UInt32), scip, randnumgen, seed) + ccall((:SCIPsetRandomSeed, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_RANDNUMGEN}, UInt32), scip, randnumgen, seed) end function SCIPinitializeRandomSeed(scip, initialseedvalue) - ccall((:SCIPinitializeRandomSeed, libscip), UInt32, (Ptr{SCIP}, UInt32), scip, initialseedvalue) + ccall((:SCIPinitializeRandomSeed, libscip), UInt32, (Ptr{SCIP_}, UInt32), scip, initialseedvalue) end diff --git a/src/wrapper/scip_reader.jl b/src/wrapper/scip_reader.jl index c330d786..321e6ebb 100644 --- a/src/wrapper/scip_reader.jl +++ b/src/wrapper/scip_reader.jl @@ -3,37 +3,37 @@ function SCIPincludeReader(scip, name, desc, extension, readercopy, readerfree, readerread, readerwrite, readerdata) - ccall((:SCIPincludeReader, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_READERDATA}), scip, name, desc, extension, readercopy, readerfree, readerread, readerwrite, readerdata) + ccall((:SCIPincludeReader, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cstring, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_READERDATA}), scip, name, desc, extension, readercopy, readerfree, readerread, readerwrite, readerdata) end function SCIPincludeReaderBasic(scip, readerptr, name, desc, extension, readerdata) - ccall((:SCIPincludeReaderBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_READER}}, Cstring, Cstring, Cstring, Ptr{SCIP_READERDATA}), scip, readerptr, name, desc, extension, readerdata) + ccall((:SCIPincludeReaderBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_READER}}, Cstring, Cstring, Cstring, Ptr{SCIP_READERDATA}), scip, readerptr, name, desc, extension, readerdata) end function SCIPsetReaderCopy(scip, reader, readercopy) - ccall((:SCIPsetReaderCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readercopy) + ccall((:SCIPsetReaderCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readercopy) end function SCIPsetReaderFree(scip, reader, readerfree) - ccall((:SCIPsetReaderFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerfree) + ccall((:SCIPsetReaderFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerfree) end function SCIPsetReaderRead(scip, reader, readerread) - ccall((:SCIPsetReaderRead, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerread) + ccall((:SCIPsetReaderRead, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerread) end function SCIPsetReaderWrite(scip, reader, readerwrite) - ccall((:SCIPsetReaderWrite, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerwrite) + ccall((:SCIPsetReaderWrite, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerwrite) end function SCIPfindReader(scip, name) - ccall((:SCIPfindReader, libscip), Ptr{SCIP_READER}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindReader, libscip), Ptr{SCIP_READER}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetReaders(scip) - ccall((:SCIPgetReaders, libscip), Ptr{Ptr{SCIP_READER}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetReaders, libscip), Ptr{Ptr{SCIP_READER}}, (Ptr{SCIP_},), scip) end function SCIPgetNReaders(scip) - ccall((:SCIPgetNReaders, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNReaders, libscip), Cint, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_relax.jl b/src/wrapper/scip_relax.jl index b9693e9c..507b8755 100644 --- a/src/wrapper/scip_relax.jl +++ b/src/wrapper/scip_relax.jl @@ -3,49 +3,49 @@ function SCIPincludeRelax(scip, name, desc, priority, freq, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) - ccall((:SCIPincludeRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, name, desc, priority, freq, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) + ccall((:SCIPincludeRelax, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, name, desc, priority, freq, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) end function SCIPincludeRelaxBasic(scip, relaxptr, name, desc, priority, freq, relaxexec, relaxdata) - ccall((:SCIPincludeRelaxBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_RELAX}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, relaxptr, name, desc, priority, freq, relaxexec, relaxdata) + ccall((:SCIPincludeRelaxBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_RELAX}}, Cstring, Cstring, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, relaxptr, name, desc, priority, freq, relaxexec, relaxdata) end function SCIPsetRelaxCopy(scip, relax, relaxcopy) - ccall((:SCIPsetRelaxCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxcopy) + ccall((:SCIPsetRelaxCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxcopy) end function SCIPsetRelaxFree(scip, relax, relaxfree) - ccall((:SCIPsetRelaxFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxfree) + ccall((:SCIPsetRelaxFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxfree) end function SCIPsetRelaxInit(scip, relax, relaxinit) - ccall((:SCIPsetRelaxInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinit) + ccall((:SCIPsetRelaxInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinit) end function SCIPsetRelaxExit(scip, relax, relaxexit) - ccall((:SCIPsetRelaxExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexit) + ccall((:SCIPsetRelaxExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexit) end function SCIPsetRelaxInitsol(scip, relax, relaxinitsol) - ccall((:SCIPsetRelaxInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinitsol) + ccall((:SCIPsetRelaxInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinitsol) end function SCIPsetRelaxExitsol(scip, relax, relaxexitsol) - ccall((:SCIPsetRelaxExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexitsol) + ccall((:SCIPsetRelaxExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexitsol) end function SCIPfindRelax(scip, name) - ccall((:SCIPfindRelax, libscip), Ptr{SCIP_RELAX}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindRelax, libscip), Ptr{SCIP_RELAX}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetRelaxs(scip) - ccall((:SCIPgetRelaxs, libscip), Ptr{Ptr{SCIP_RELAX}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetRelaxs, libscip), Ptr{Ptr{SCIP_RELAX}}, (Ptr{SCIP_},), scip) end function SCIPgetNRelaxs(scip) - ccall((:SCIPgetNRelaxs, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNRelaxs, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetRelaxPriority(scip, relax, priority) - ccall((:SCIPsetRelaxPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint), scip, relax, priority) + ccall((:SCIPsetRelaxPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_RELAX}, Cint), scip, relax, priority) end diff --git a/src/wrapper/scip_reopt.jl b/src/wrapper/scip_reopt.jl index 0dffd9db..bc1d8e04 100644 --- a/src/wrapper/scip_reopt.jl +++ b/src/wrapper/scip_reopt.jl @@ -3,77 +3,77 @@ function SCIPgetReoptChildIDs(scip, node, ids, mem, nids) - ccall((:SCIPgetReoptChildIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}, Cint, Ptr{Cint}), scip, node, ids, mem, nids) + ccall((:SCIPgetReoptChildIDs, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{UInt32}, Cint, Ptr{Cint}), scip, node, ids, mem, nids) end function SCIPgetReoptLeaveIDs(scip, node, ids, mem, nids) - ccall((:SCIPgetReoptLeaveIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}, Cint, Ptr{Cint}), scip, node, ids, mem, nids) + ccall((:SCIPgetReoptLeaveIDs, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{UInt32}, Cint, Ptr{Cint}), scip, node, ids, mem, nids) end function SCIPgetNReoptnodes(scip, node) - ccall((:SCIPgetNReoptnodes, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall((:SCIPgetNReoptnodes, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_NODE}), scip, node) end function SCIPgetNReoptLeaves(scip, node) - ccall((:SCIPgetNReoptLeaves, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall((:SCIPgetNReoptLeaves, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_NODE}), scip, node) end function SCIPgetReoptnode(scip, id) - ccall((:SCIPgetReoptnode, libscip), Ptr{SCIP_REOPTNODE}, (Ptr{SCIP}, UInt32), scip, id) + ccall((:SCIPgetReoptnode, libscip), Ptr{SCIP_REOPTNODE}, (Ptr{SCIP_}, UInt32), scip, id) end function SCIPaddReoptnodeBndchg(scip, reoptnode, var, bound, boundtype) - ccall((:SCIPaddReoptnodeBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{SCIP_VAR}, Cdouble, SCIP_BOUNDTYPE), scip, reoptnode, var, bound, boundtype) + ccall((:SCIPaddReoptnodeBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_REOPTNODE}, Ptr{SCIP_VAR}, Cdouble, SCIP_BOUNDTYPE), scip, reoptnode, var, bound, boundtype) end function SCIPsetReoptCompression(scip, representation, nrepresentatives, success) - ccall((:SCIPsetReoptCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint, Ptr{UInt32}), scip, representation, nrepresentatives, success) + ccall((:SCIPsetReoptCompression, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint, Ptr{UInt32}), scip, representation, nrepresentatives, success) end function SCIPaddReoptnodeCons(scip, reoptnode, vars, vals, boundtypes, lhs, rhs, nvars, constype, linear) - ccall((:SCIPaddReoptnodeCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cdouble, Cdouble, Cint, REOPT_CONSTYPE, UInt32), scip, reoptnode, vars, vals, boundtypes, lhs, rhs, nvars, constype, linear) + ccall((:SCIPaddReoptnodeCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cdouble, Cdouble, Cint, REOPT_CONSTYPE, UInt32), scip, reoptnode, vars, vals, boundtypes, lhs, rhs, nvars, constype, linear) end function SCIPgetReoptnodePath(scip, reoptnode, vars, vals, boundtypes, mem, nvars, nafterdualvars) - ccall((:SCIPgetReoptnodePath, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cint, Ptr{Cint}, Ptr{Cint}), scip, reoptnode, vars, vals, boundtypes, mem, nvars, nafterdualvars) + ccall((:SCIPgetReoptnodePath, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cint, Ptr{Cint}, Ptr{Cint}), scip, reoptnode, vars, vals, boundtypes, mem, nvars, nafterdualvars) end function SCIPinitRepresentation(scip, representatives, nrepresentatives) - ccall((:SCIPinitRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) + ccall((:SCIPinitRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) end function SCIPresetRepresentation(scip, representatives, nrepresentatives) - ccall((:SCIPresetRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) + ccall((:SCIPresetRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) end function SCIPfreeRepresentation(scip, representatives, nrepresentatives) - ccall((:SCIPfreeRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) + ccall((:SCIPfreeRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) end function SCIPapplyReopt(scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) - ccall((:SCIPapplyReopt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, UInt32, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{UInt32}), scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) + ccall((:SCIPapplyReopt, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_REOPTNODE}, UInt32, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{UInt32}), scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) end function SCIPresetReoptnodeDualcons(scip, node) - ccall((:SCIPresetReoptnodeDualcons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall((:SCIPresetReoptnodeDualcons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}), scip, node) end function SCIPsplitReoptRoot(scip, ncreatedchilds, naddedconss) - ccall((:SCIPsplitReoptRoot, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}), scip, ncreatedchilds, naddedconss) + ccall((:SCIPsplitReoptRoot, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Cint}, Ptr{Cint}), scip, ncreatedchilds, naddedconss) end function SCIPreoptimizeNode(scip, node) - ccall((:SCIPreoptimizeNode, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall((:SCIPreoptimizeNode, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_NODE}), scip, node) end function SCIPdeleteReoptnode(scip, reoptnode) - ccall((:SCIPdeleteReoptnode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}), scip, reoptnode) + ccall((:SCIPdeleteReoptnode, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_REOPTNODE}}), scip, reoptnode) end function SCIPgetReoptSimilarity(scip, run1, run2) - ccall((:SCIPgetReoptSimilarity, libscip), Cdouble, (Ptr{SCIP}, Cint, Cint), scip, run1, run2) + ccall((:SCIPgetReoptSimilarity, libscip), Cdouble, (Ptr{SCIP_}, Cint, Cint), scip, run1, run2) end function SCIPgetVarCoefChg(scip, varidx, negated, entering, leaving) - ccall((:SCIPgetVarCoefChg, libscip), Cvoid, (Ptr{SCIP}, Cint, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, varidx, negated, entering, leaving) + ccall((:SCIPgetVarCoefChg, libscip), Cvoid, (Ptr{SCIP_}, Cint, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, varidx, negated, entering, leaving) end diff --git a/src/wrapper/scip_sepa.jl b/src/wrapper/scip_sepa.jl index aa0d53ab..8cc68cc7 100644 --- a/src/wrapper/scip_sepa.jl +++ b/src/wrapper/scip_sepa.jl @@ -3,53 +3,53 @@ function SCIPincludeSepa(scip, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) - ccall((:SCIPincludeSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, Cint, Cint, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) + ccall((:SCIPincludeSepa, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, Cint, Cint, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepacopy, sepafree, sepainit, sepaexit, sepainitsol, sepaexitsol, sepaexeclp, sepaexecsol, sepadata) end function SCIPincludeSepaBasic(scip, sepa, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepaexeclp, sepaexecsol, sepadata) - ccall((:SCIPincludeSepaBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SEPA}}, Cstring, Cstring, Cint, Cint, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, sepa, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepaexeclp, sepaexecsol, sepadata) + ccall((:SCIPincludeSepaBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SEPA}}, Cstring, Cstring, Cint, Cint, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, sepa, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepaexeclp, sepaexecsol, sepadata) end function SCIPsetSepaCopy(scip, sepa, sepacopy) - ccall((:SCIPsetSepaCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepacopy) + ccall((:SCIPsetSepaCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepacopy) end function SCIPsetSepaFree(scip, sepa, sepafree) - ccall((:SCIPsetSepaFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepafree) + ccall((:SCIPsetSepaFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepafree) end function SCIPsetSepaInit(scip, sepa, sepainit) - ccall((:SCIPsetSepaInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainit) + ccall((:SCIPsetSepaInit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainit) end function SCIPsetSepaExit(scip, sepa, sepaexit) - ccall((:SCIPsetSepaExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexit) + ccall((:SCIPsetSepaExit, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexit) end function SCIPsetSepaInitsol(scip, sepa, sepainitsol) - ccall((:SCIPsetSepaInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainitsol) + ccall((:SCIPsetSepaInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainitsol) end function SCIPsetSepaExitsol(scip, sepa, sepaexitsol) - ccall((:SCIPsetSepaExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexitsol) + ccall((:SCIPsetSepaExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexitsol) end function SCIPfindSepa(scip, name) - ccall((:SCIPfindSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetSepas(scip) - ccall((:SCIPgetSepas, libscip), Ptr{Ptr{SCIP_SEPA}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetSepas, libscip), Ptr{Ptr{SCIP_SEPA}}, (Ptr{SCIP_},), scip) end function SCIPgetNSepas(scip) - ccall((:SCIPgetNSepas, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNSepas, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPsetSepaPriority(scip, sepa, priority) - ccall((:SCIPsetSepaPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Cint), scip, sepa, priority) + ccall((:SCIPsetSepaPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SEPA}, Cint), scip, sepa, priority) end function SCIPgetSepaMinEfficacy(scip) - ccall((:SCIPgetSepaMinEfficacy, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetSepaMinEfficacy, libscip), Cdouble, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_sol.jl b/src/wrapper/scip_sol.jl index 3c2c09e8..461fa62f 100644 --- a/src/wrapper/scip_sol.jl +++ b/src/wrapper/scip_sol.jl @@ -3,289 +3,289 @@ function SCIPcreateSol(scip, sol, heur) - ccall((:SCIPcreateSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreateSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateLPSol(scip, sol, heur) - ccall((:SCIPcreateLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreateLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateNLPSol(scip, sol, heur) - ccall((:SCIPcreateNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreateNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateRelaxSol(scip, sol, heur) - ccall((:SCIPcreateRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreateRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreatePseudoSol(scip, sol, heur) - ccall((:SCIPcreatePseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreatePseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateCurrentSol(scip, sol, heur) - ccall((:SCIPcreateCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreateCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreatePartialSol(scip, sol, heur) - ccall((:SCIPcreatePartialSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreatePartialSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateUnknownSol(scip, sol, heur) - ccall((:SCIPcreateUnknownSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreateUnknownSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateOrigSol(scip, sol, heur) - ccall((:SCIPcreateOrigSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall((:SCIPcreateOrigSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateSolCopy(scip, sol, sourcesol) - ccall((:SCIPcreateSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) + ccall((:SCIPcreateSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) end function SCIPcreateSolCopyOrig(scip, sol, sourcesol) - ccall((:SCIPcreateSolCopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) + ccall((:SCIPcreateSolCopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) end function SCIPcreateFiniteSolCopy(scip, sol, sourcesol, success) - ccall((:SCIPcreateFiniteSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, sourcesol, success) + ccall((:SCIPcreateFiniteSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, sourcesol, success) end function SCIPfreeSol(scip, sol) - ccall((:SCIPfreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}), scip, sol) + ccall((:SCIPfreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}), scip, sol) end function SCIPlinkLPSol(scip, sol) - ccall((:SCIPlinkLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPlinkLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPlinkNLPSol(scip, sol) - ccall((:SCIPlinkNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPlinkNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPlinkRelaxSol(scip, sol) - ccall((:SCIPlinkRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPlinkRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPlinkPseudoSol(scip, sol) - ccall((:SCIPlinkPseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPlinkPseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPlinkCurrentSol(scip, sol) - ccall((:SCIPlinkCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPlinkCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPclearSol(scip, sol) - ccall((:SCIPclearSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPclearSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPunlinkSol(scip, sol) - ccall((:SCIPunlinkSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPunlinkSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPsetSolVal(scip, sol, var, val) - ccall((:SCIPsetSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, val) + ccall((:SCIPsetSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, val) end function SCIPsetSolVals(scip, sol, nvars, vars, vals) - ccall((:SCIPsetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) + ccall((:SCIPsetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) end function SCIPincSolVal(scip, sol, var, incval) - ccall((:SCIPincSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, incval) + ccall((:SCIPincSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, incval) end function SCIPgetSolVal(scip, sol, var) - ccall((:SCIPgetSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}), scip, sol, var) + ccall((:SCIPgetSolVal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}), scip, sol, var) end function SCIPgetSolVals(scip, sol, nvars, vars, vals) - ccall((:SCIPgetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) + ccall((:SCIPgetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) end function SCIPgetSolOrigObj(scip, sol) - ccall((:SCIPgetSolOrigObj, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPgetSolOrigObj, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPgetSolTransObj(scip, sol) - ccall((:SCIPgetSolTransObj, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPgetSolTransObj, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPrecomputeSolObj(scip, sol) - ccall((:SCIPrecomputeSolObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPrecomputeSolObj, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPtransformObj(scip, obj) - ccall((:SCIPtransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) + ccall((:SCIPtransformObj, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, obj) end function SCIPretransformObj(scip, obj) - ccall((:SCIPretransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) + ccall((:SCIPretransformObj, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, obj) end function SCIPgetSolTime(scip, sol) - ccall((:SCIPgetSolTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPgetSolTime, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPgetSolRunnum(scip, sol) - ccall((:SCIPgetSolRunnum, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPgetSolRunnum, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPgetSolNodenum(scip, sol) - ccall((:SCIPgetSolNodenum, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPgetSolNodenum, libscip), Clonglong, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPgetSolHeur(scip, sol) - ccall((:SCIPgetSolHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPgetSolHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPareSolsEqual(scip, sol1, sol2) - ccall((:SCIPareSolsEqual, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_SOL}), scip, sol1, sol2) + ccall((:SCIPareSolsEqual, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{SCIP_SOL}), scip, sol1, sol2) end function SCIPadjustImplicitSolVals(scip, sol, uselprows) - ccall((:SCIPadjustImplicitSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32), scip, sol, uselprows) + ccall((:SCIPadjustImplicitSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, UInt32), scip, sol, uselprows) end function SCIPprintSol(scip, sol, file, printzeros) - ccall((:SCIPprintSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) + ccall((:SCIPprintSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) end function SCIPprintTransSol(scip, sol, file, printzeros) - ccall((:SCIPprintTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) + ccall((:SCIPprintTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) end function SCIPprintMIPStart(scip, sol, file) - ccall((:SCIPprintMIPStart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}), scip, sol, file) + ccall((:SCIPprintMIPStart, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{FILE}), scip, sol, file) end function SCIPgetDualSolVal(scip, cons, dualsolval, boundconstraint) - ccall((:SCIPgetDualSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{UInt32}), scip, cons, dualsolval, boundconstraint) + ccall((:SCIPgetDualSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{UInt32}), scip, cons, dualsolval, boundconstraint) end function SCIPisDualSolAvailable(scip, printreason) - ccall((:SCIPisDualSolAvailable, libscip), UInt32, (Ptr{SCIP}, UInt32), scip, printreason) + ccall((:SCIPisDualSolAvailable, libscip), UInt32, (Ptr{SCIP_}, UInt32), scip, printreason) end function SCIPprintDualSol(scip, file, printzeros) - ccall((:SCIPprintDualSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) + ccall((:SCIPprintDualSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, UInt32), scip, file, printzeros) end function SCIPprintRay(scip, sol, file, printzeros) - ccall((:SCIPprintRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) + ccall((:SCIPprintRay, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{FILE}, UInt32), scip, sol, file, printzeros) end function SCIPgetNSols(scip) - ccall((:SCIPgetNSols, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNSols, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetSols(scip) - ccall((:SCIPgetSols, libscip), Ptr{Ptr{SCIP_SOL}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetSols, libscip), Ptr{Ptr{SCIP_SOL}}, (Ptr{SCIP_},), scip) end function SCIPgetBestSol(scip) - ccall((:SCIPgetBestSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP},), scip) + ccall((:SCIPgetBestSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP_},), scip) end function SCIPprintBestSol(scip, file, printzeros) - ccall((:SCIPprintBestSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) + ccall((:SCIPprintBestSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, UInt32), scip, file, printzeros) end function SCIPprintBestTransSol(scip, file, printzeros) - ccall((:SCIPprintBestTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, UInt32), scip, file, printzeros) + ccall((:SCIPprintBestTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, UInt32), scip, file, printzeros) end function SCIProundSol(scip, sol, success) - ccall((:SCIProundSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, success) + ccall((:SCIProundSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, success) end function SCIPretransformSol(scip, sol) - ccall((:SCIPretransformSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall((:SCIPretransformSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, sol) end function SCIPreadSol(scip, filename) - ccall((:SCIPreadSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) + ccall((:SCIPreadSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, filename) end function SCIPreadSolFile(scip, filename, sol, xml, partial, error) - ccall((:SCIPreadSolFile, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{SCIP_SOL}, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, filename, sol, xml, partial, error) + ccall((:SCIPreadSolFile, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{SCIP_SOL}, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, filename, sol, xml, partial, error) end function SCIPaddSol(scip, sol, stored) - ccall((:SCIPaddSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, stored) + ccall((:SCIPaddSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{UInt32}), scip, sol, stored) end function SCIPaddSolFree(scip, sol, stored) - ccall((:SCIPaddSolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{UInt32}), scip, sol, stored) + ccall((:SCIPaddSolFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, Ptr{UInt32}), scip, sol, stored) end function SCIPaddCurrentSol(scip, heur, stored) - ccall((:SCIPaddCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{UInt32}), scip, heur, stored) + ccall((:SCIPaddCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, Ptr{UInt32}), scip, heur, stored) end function SCIPtrySol(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) - ccall((:SCIPtrySol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) + ccall((:SCIPtrySol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) end function SCIPtrySolFree(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) - ccall((:SCIPtrySolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) + ccall((:SCIPtrySolFree, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_SOL}}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) end function SCIPtryCurrentSol(scip, heur, printreason, completely, checkintegrality, checklprows, stored) - ccall((:SCIPtryCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, heur, printreason, completely, checkintegrality, checklprows, stored) + ccall((:SCIPtryCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_HEUR}, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, heur, printreason, completely, checkintegrality, checklprows, stored) end function SCIPgetPartialSols(scip) - ccall((:SCIPgetPartialSols, libscip), Ptr{Ptr{SCIP_SOL}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetPartialSols, libscip), Ptr{Ptr{SCIP_SOL}}, (Ptr{SCIP_},), scip) end function SCIPgetNPartialSols(scip) - ccall((:SCIPgetNPartialSols, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPartialSols, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPcheckSol(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) - ccall((:SCIPcheckSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) + ccall((:SCIPcheckSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, UInt32, UInt32, UInt32, UInt32, UInt32, Ptr{UInt32}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) end function SCIPcheckSolOrig(scip, sol, feasible, printreason, completely) - ccall((:SCIPcheckSolOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{UInt32}, UInt32, UInt32), scip, sol, feasible, printreason, completely) + ccall((:SCIPcheckSolOrig, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Ptr{UInt32}, UInt32, UInt32), scip, sol, feasible, printreason, completely) end function SCIPupdateSolIntegralityViolation(scip, sol, absviol) - ccall((:SCIPupdateSolIntegralityViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble), scip, sol, absviol) + ccall((:SCIPupdateSolIntegralityViolation, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Cdouble), scip, sol, absviol) end function SCIPupdateSolBoundViolation(scip, sol, absviol, relviol) - ccall((:SCIPupdateSolBoundViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) + ccall((:SCIPupdateSolBoundViolation, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end function SCIPupdateSolLPRowViolation(scip, sol, absviol, relviol) - ccall((:SCIPupdateSolLPRowViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) + ccall((:SCIPupdateSolLPRowViolation, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end function SCIPupdateSolConsViolation(scip, sol, absviol, relviol) - ccall((:SCIPupdateSolConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) + ccall((:SCIPupdateSolConsViolation, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end function SCIPupdateSolLPConsViolation(scip, sol, absviol, relviol) - ccall((:SCIPupdateSolLPConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) + ccall((:SCIPupdateSolLPConsViolation, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end function SCIPactivateSolViolationUpdates(scip) - ccall((:SCIPactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPdeactivateSolViolationUpdates(scip) - ccall((:SCIPdeactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPdeactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPhasPrimalRay(scip) - ccall((:SCIPhasPrimalRay, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPhasPrimalRay, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetPrimalRayVal(scip, var) - ccall((:SCIPgetPrimalRayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetPrimalRayVal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPupdatePrimalRay(scip, primalray) - ccall((:SCIPupdatePrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, primalray) + ccall((:SCIPupdatePrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}), scip, primalray) end diff --git a/src/wrapper/scip_solve.jl b/src/wrapper/scip_solve.jl index 412770d9..af58ec17 100644 --- a/src/wrapper/scip_solve.jl +++ b/src/wrapper/scip_solve.jl @@ -3,77 +3,77 @@ function SCIPtransformProb(scip) - ccall((:SCIPtransformProb, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPtransformProb, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPpresolve(scip) - ccall((:SCIPpresolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPpresolve, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPsolve(scip) - ccall((:SCIPsolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPsolve, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPsolveParallel(scip) - ccall((:SCIPsolveParallel, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPsolveParallel, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPsolveConcurrent(scip) - ccall((:SCIPsolveConcurrent, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPsolveConcurrent, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPfreeSolve(scip, restart) - ccall((:SCIPfreeSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, restart) + ccall((:SCIPfreeSolve, libscip), SCIP_RETCODE, (Ptr{SCIP_}, UInt32), scip, restart) end function SCIPfreeReoptSolve(scip) - ccall((:SCIPfreeReoptSolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPfreeReoptSolve, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPfreeTransform(scip) - ccall((:SCIPfreeTransform, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPfreeTransform, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPinterruptSolve(scip) - ccall((:SCIPinterruptSolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPinterruptSolve, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPrestartSolve(scip) - ccall((:SCIPrestartSolve, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPrestartSolve, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPenableReoptimization(scip, enable) - ccall((:SCIPenableReoptimization, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, enable) + ccall((:SCIPenableReoptimization, libscip), SCIP_RETCODE, (Ptr{SCIP_}, UInt32), scip, enable) end function SCIPisReoptEnabled(scip) - ccall((:SCIPisReoptEnabled, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisReoptEnabled, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetReoptSolsRun(scip, run, sols, allocmem, nsols) - ccall((:SCIPgetReoptSolsRun, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_SOL}}, Cint, Ptr{Cint}), scip, run, sols, allocmem, nsols) + ccall((:SCIPgetReoptSolsRun, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_SOL}}, Cint, Ptr{Cint}), scip, run, sols, allocmem, nsols) end function SCIPresetReoptSolMarks(scip) - ccall((:SCIPresetReoptSolMarks, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPresetReoptSolMarks, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPcheckReoptRestart(scip, node, restart) - ccall((:SCIPcheckReoptRestart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{UInt32}), scip, node, restart) + ccall((:SCIPcheckReoptRestart, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{UInt32}), scip, node, restart) end function SCIPaddReoptDualBndchg(scip, node, var, newbound, oldbound) - ccall((:SCIPaddReoptDualBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, node, var, newbound, oldbound) + ccall((:SCIPaddReoptDualBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, node, var, newbound, oldbound) end function SCIPgetReoptLastOptSol(scip) - ccall((:SCIPgetReoptLastOptSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP},), scip) + ccall((:SCIPgetReoptLastOptSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP_},), scip) end function SCIPgetReoptOldObjCoef(scip, var, run, objcoef) - ccall((:SCIPgetReoptOldObjCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, run, objcoef) + ccall((:SCIPgetReoptOldObjCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, run, objcoef) end function SCIPisInRestart(scip) - ccall((:SCIPisInRestart, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisInRestart, libscip), UInt32, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_solvingstats.jl b/src/wrapper/scip_solvingstats.jl index 2b7cc9b9..9061aa47 100644 --- a/src/wrapper/scip_solvingstats.jl +++ b/src/wrapper/scip_solvingstats.jl @@ -3,493 +3,493 @@ function SCIPgetNRuns(scip) - ccall((:SCIPgetNRuns, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNRuns, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNReoptRuns(scip) - ccall((:SCIPgetNReoptRuns, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNReoptRuns, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPaddNNodes(scip, nnodes) - ccall((:SCIPaddNNodes, libscip), Cvoid, (Ptr{SCIP}, Clonglong), scip, nnodes) + ccall((:SCIPaddNNodes, libscip), Cvoid, (Ptr{SCIP_}, Clonglong), scip, nnodes) end function SCIPgetNNodes(scip) - ccall((:SCIPgetNNodes, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNodes, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNTotalNodes(scip) - ccall((:SCIPgetNTotalNodes, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNTotalNodes, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNFeasibleLeaves(scip) - ccall((:SCIPgetNFeasibleLeaves, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNFeasibleLeaves, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNInfeasibleLeaves(scip) - ccall((:SCIPgetNInfeasibleLeaves, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNInfeasibleLeaves, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNObjlimLeaves(scip) - ccall((:SCIPgetNObjlimLeaves, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNObjlimLeaves, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNDelayedCutoffs(scip) - ccall((:SCIPgetNDelayedCutoffs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDelayedCutoffs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNLPs(scip) - ccall((:SCIPgetNLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNLPIterations(scip) - ccall((:SCIPgetNLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNNZs(scip) - ccall((:SCIPgetNNZs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNZs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNRootLPIterations(scip) - ccall((:SCIPgetNRootLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNRootLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNRootFirstLPIterations(scip) - ccall((:SCIPgetNRootFirstLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNRootFirstLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNPrimalLPs(scip) - ccall((:SCIPgetNPrimalLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrimalLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNPrimalLPIterations(scip) - ccall((:SCIPgetNPrimalLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrimalLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNDualLPs(scip) - ccall((:SCIPgetNDualLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDualLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNDualLPIterations(scip) - ccall((:SCIPgetNDualLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDualLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNBarrierLPs(scip) - ccall((:SCIPgetNBarrierLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNBarrierLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNBarrierLPIterations(scip) - ccall((:SCIPgetNBarrierLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNBarrierLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNResolveLPs(scip) - ccall((:SCIPgetNResolveLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNResolveLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNResolveLPIterations(scip) - ccall((:SCIPgetNResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNResolveLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNPrimalResolveLPs(scip) - ccall((:SCIPgetNPrimalResolveLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrimalResolveLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNPrimalResolveLPIterations(scip) - ccall((:SCIPgetNPrimalResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPrimalResolveLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNDualResolveLPs(scip) - ccall((:SCIPgetNDualResolveLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDualResolveLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNDualResolveLPIterations(scip) - ccall((:SCIPgetNDualResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDualResolveLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNNodeLPs(scip) - ccall((:SCIPgetNNodeLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNodeLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNNodeLPIterations(scip) - ccall((:SCIPgetNNodeLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNodeLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNNodeInitLPs(scip) - ccall((:SCIPgetNNodeInitLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNodeInitLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNNodeInitLPIterations(scip) - ccall((:SCIPgetNNodeInitLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNodeInitLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNDivingLPs(scip) - ccall((:SCIPgetNDivingLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDivingLPs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNDivingLPIterations(scip) - ccall((:SCIPgetNDivingLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNDivingLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNStrongbranchs(scip) - ccall((:SCIPgetNStrongbranchs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNStrongbranchs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNStrongbranchLPIterations(scip) - ccall((:SCIPgetNStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNRootStrongbranchs(scip) - ccall((:SCIPgetNRootStrongbranchs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNRootStrongbranchs, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNRootStrongbranchLPIterations(scip) - ccall((:SCIPgetNRootStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNRootStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNPriceRounds(scip) - ccall((:SCIPgetNPriceRounds, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPriceRounds, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPricevars(scip) - ccall((:SCIPgetNPricevars, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPricevars, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPricevarsFound(scip) - ccall((:SCIPgetNPricevarsFound, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPricevarsFound, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNPricevarsApplied(scip) - ccall((:SCIPgetNPricevarsApplied, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNPricevarsApplied, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNSepaRounds(scip) - ccall((:SCIPgetNSepaRounds, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNSepaRounds, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNCutsFound(scip) - ccall((:SCIPgetNCutsFound, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNCutsFound, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNCutsFoundRound(scip) - ccall((:SCIPgetNCutsFoundRound, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNCutsFoundRound, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNCutsApplied(scip) - ccall((:SCIPgetNCutsApplied, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNCutsApplied, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNConflictConssFound(scip) - ccall((:SCIPgetNConflictConssFound, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNConflictConssFound, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNConflictConssFoundNode(scip) - ccall((:SCIPgetNConflictConssFoundNode, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNConflictConssFoundNode, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNConflictConssApplied(scip) - ccall((:SCIPgetNConflictConssApplied, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNConflictConssApplied, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetMaxDepth(scip) - ccall((:SCIPgetMaxDepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetMaxDepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetMaxTotalDepth(scip) - ccall((:SCIPgetMaxTotalDepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetMaxTotalDepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNBacktracks(scip) - ccall((:SCIPgetNBacktracks, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNBacktracks, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNActiveConss(scip) - ccall((:SCIPgetNActiveConss, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNActiveConss, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNEnabledConss(scip) - ccall((:SCIPgetNEnabledConss, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNEnabledConss, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetAvgDualbound(scip) - ccall((:SCIPgetAvgDualbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgDualbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgLowerbound(scip) - ccall((:SCIPgetAvgLowerbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgLowerbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetDualbound(scip) - ccall((:SCIPgetDualbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetDualbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLowerbound(scip) - ccall((:SCIPgetLowerbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLowerbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetDualboundRoot(scip) - ccall((:SCIPgetDualboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetDualboundRoot, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetLowerboundRoot(scip) - ccall((:SCIPgetLowerboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetLowerboundRoot, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetFirstLPDualboundRoot(scip) - ccall((:SCIPgetFirstLPDualboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetFirstLPDualboundRoot, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetFirstLPLowerboundRoot(scip) - ccall((:SCIPgetFirstLPLowerboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetFirstLPLowerboundRoot, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetFirstPrimalBound(scip) - ccall((:SCIPgetFirstPrimalBound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetFirstPrimalBound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetPrimalbound(scip) - ccall((:SCIPgetPrimalbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetPrimalbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetUpperbound(scip) - ccall((:SCIPgetUpperbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetUpperbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetCutoffbound(scip) - ccall((:SCIPgetCutoffbound, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetCutoffbound, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPupdateCutoffbound(scip, cutoffbound) - ccall((:SCIPupdateCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, cutoffbound) + ccall((:SCIPupdateCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble), scip, cutoffbound) end function SCIPisPrimalboundSol(scip) - ccall((:SCIPisPrimalboundSol, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisPrimalboundSol, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetGap(scip) - ccall((:SCIPgetGap, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetGap, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetTransGap(scip) - ccall((:SCIPgetTransGap, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetTransGap, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetNSolsFound(scip) - ccall((:SCIPgetNSolsFound, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNSolsFound, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNLimSolsFound(scip) - ccall((:SCIPgetNLimSolsFound, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLimSolsFound, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetNBestSolsFound(scip) - ccall((:SCIPgetNBestSolsFound, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall((:SCIPgetNBestSolsFound, libscip), Clonglong, (Ptr{SCIP_},), scip) end function SCIPgetAvgPseudocost(scip, solvaldelta) - ccall((:SCIPgetAvgPseudocost, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) + ccall((:SCIPgetAvgPseudocost, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, solvaldelta) end function SCIPgetAvgPseudocostCurrentRun(scip, solvaldelta) - ccall((:SCIPgetAvgPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) + ccall((:SCIPgetAvgPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, solvaldelta) end function SCIPgetAvgPseudocostCount(scip, dir) - ccall((:SCIPgetAvgPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall((:SCIPgetAvgPseudocostCount, libscip), Cdouble, (Ptr{SCIP_}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgPseudocostCountCurrentRun(scip, dir) - ccall((:SCIPgetAvgPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall((:SCIPgetAvgPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetPseudocostCount(scip, dir, onlycurrentrun) - ccall((:SCIPgetPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, UInt32), scip, dir, onlycurrentrun) + ccall((:SCIPgetPseudocostCount, libscip), Cdouble, (Ptr{SCIP_}, SCIP_BRANCHDIR, UInt32), scip, dir, onlycurrentrun) end function SCIPgetAvgPseudocostScore(scip) - ccall((:SCIPgetAvgPseudocostScore, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgPseudocostScore, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetPseudocostVariance(scip, branchdir, onlycurrentrun) - ccall((:SCIPgetPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, UInt32), scip, branchdir, onlycurrentrun) + ccall((:SCIPgetPseudocostVariance, libscip), Cdouble, (Ptr{SCIP_}, SCIP_BRANCHDIR, UInt32), scip, branchdir, onlycurrentrun) end function SCIPgetAvgPseudocostScoreCurrentRun(scip) - ccall((:SCIPgetAvgPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgConflictScore(scip) - ccall((:SCIPgetAvgConflictScore, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgConflictScore, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgConflictScoreCurrentRun(scip) - ccall((:SCIPgetAvgConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgConflictlengthScore(scip) - ccall((:SCIPgetAvgConflictlengthScore, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgConflictlengthScore, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgConflictlengthScoreCurrentRun(scip) - ccall((:SCIPgetAvgConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgInferences(scip, dir) - ccall((:SCIPgetAvgInferences, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall((:SCIPgetAvgInferences, libscip), Cdouble, (Ptr{SCIP_}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgInferencesCurrentRun(scip, dir) - ccall((:SCIPgetAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall((:SCIPgetAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgInferenceScore(scip) - ccall((:SCIPgetAvgInferenceScore, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgInferenceScore, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgInferenceScoreCurrentRun(scip) - ccall((:SCIPgetAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgCutoffs(scip, dir) - ccall((:SCIPgetAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall((:SCIPgetAvgCutoffs, libscip), Cdouble, (Ptr{SCIP_}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgCutoffsCurrentRun(scip, dir) - ccall((:SCIPgetAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall((:SCIPgetAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgCutoffScore(scip) - ccall((:SCIPgetAvgCutoffScore, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgCutoffScore, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetAvgCutoffScoreCurrentRun(scip) - ccall((:SCIPgetAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetDeterministicTime(scip) - ccall((:SCIPgetDeterministicTime, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetDeterministicTime, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPprintOrigProblem(scip, file, extension, genericnames) - ccall((:SCIPprintOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Cstring, UInt32), scip, file, extension, genericnames) + ccall((:SCIPprintOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, Cstring, UInt32), scip, file, extension, genericnames) end function SCIPprintTransProblem(scip, file, extension, genericnames) - ccall((:SCIPprintTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Cstring, UInt32), scip, file, extension, genericnames) + ccall((:SCIPprintTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, Cstring, UInt32), scip, file, extension, genericnames) end function SCIPprintStatusStatistics(scip, file) - ccall((:SCIPprintStatusStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintStatusStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintTimingStatistics(scip, file) - ccall((:SCIPprintTimingStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintTimingStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintOrigProblemStatistics(scip, file) - ccall((:SCIPprintOrigProblemStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintOrigProblemStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintTransProblemStatistics(scip, file) - ccall((:SCIPprintTransProblemStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintTransProblemStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintPresolverStatistics(scip, file) - ccall((:SCIPprintPresolverStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintPresolverStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintConstraintStatistics(scip, file) - ccall((:SCIPprintConstraintStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintConstraintStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintConstraintTimingStatistics(scip, file) - ccall((:SCIPprintConstraintTimingStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintConstraintTimingStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintPropagatorStatistics(scip, file) - ccall((:SCIPprintPropagatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintPropagatorStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintConflictStatistics(scip, file) - ccall((:SCIPprintConflictStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintConflictStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintSeparatorStatistics(scip, file) - ccall((:SCIPprintSeparatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintSeparatorStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintPricerStatistics(scip, file) - ccall((:SCIPprintPricerStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintPricerStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintBranchruleStatistics(scip, file) - ccall((:SCIPprintBranchruleStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintBranchruleStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintHeuristicStatistics(scip, file) - ccall((:SCIPprintHeuristicStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintHeuristicStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintCompressionStatistics(scip, file) - ccall((:SCIPprintCompressionStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintCompressionStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintLPStatistics(scip, file) - ccall((:SCIPprintLPStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintLPStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintNLPStatistics(scip, file) - ccall((:SCIPprintNLPStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintNLPStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintRelaxatorStatistics(scip, file) - ccall((:SCIPprintRelaxatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintRelaxatorStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintTreeStatistics(scip, file) - ccall((:SCIPprintTreeStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintTreeStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintRootStatistics(scip, file) - ccall((:SCIPprintRootStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintRootStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintSolutionStatistics(scip, file) - ccall((:SCIPprintSolutionStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintSolutionStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintConcsolverStatistics(scip, file) - ccall((:SCIPprintConcsolverStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintConcsolverStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintBendersStatistics(scip, file) - ccall((:SCIPprintBendersStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintBendersStatistics, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintStatistics(scip, file) - ccall((:SCIPprintStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintReoptStatistics(scip, file) - ccall((:SCIPprintReoptStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintReoptStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintBranchingStatistics(scip, file) - ccall((:SCIPprintBranchingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}), scip, file) + ccall((:SCIPprintBranchingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}), scip, file) end function SCIPprintDisplayLine(scip, file, verblevel, endline) - ccall((:SCIPprintDisplayLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, SCIP_VERBLEVEL, UInt32), scip, file, verblevel, endline) + ccall((:SCIPprintDisplayLine, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, SCIP_VERBLEVEL, UInt32), scip, file, verblevel, endline) end function SCIPgetNImplications(scip) - ccall((:SCIPgetNImplications, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNImplications, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPwriteImplicationConflictGraph(scip, filename) - ccall((:SCIPwriteImplicationConflictGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring), scip, filename) + ccall((:SCIPwriteImplicationConflictGraph, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring), scip, filename) end function SCIPstoreSolutionGap(scip) - ccall((:SCIPstoreSolutionGap, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPstoreSolutionGap, libscip), Cvoid, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_table.jl b/src/wrapper/scip_table.jl index d257b8d9..1d889a33 100644 --- a/src/wrapper/scip_table.jl +++ b/src/wrapper/scip_table.jl @@ -3,17 +3,17 @@ function SCIPincludeTable(scip, name, desc, active, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tabledata, position, earlieststage) - ccall((:SCIPincludeTable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Cstring, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_TABLEDATA}, Cint, SCIP_STAGE), scip, name, desc, active, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tabledata, position, earlieststage) + ccall((:SCIPincludeTable, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Cstring, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_TABLEDATA}, Cint, SCIP_STAGE), scip, name, desc, active, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tabledata, position, earlieststage) end function SCIPfindTable(scip, name) - ccall((:SCIPfindTable, libscip), Ptr{SCIP_TABLE}, (Ptr{SCIP}, Cstring), scip, name) + ccall((:SCIPfindTable, libscip), Ptr{SCIP_TABLE}, (Ptr{SCIP_}, Cstring), scip, name) end function SCIPgetTables(scip) - ccall((:SCIPgetTables, libscip), Ptr{Ptr{SCIP_TABLE}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetTables, libscip), Ptr{Ptr{SCIP_TABLE}}, (Ptr{SCIP_},), scip) end function SCIPgetNTables(scip) - ccall((:SCIPgetNTables, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNTables, libscip), Cint, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_timing.jl b/src/wrapper/scip_timing.jl index 25548d56..19e76961 100644 --- a/src/wrapper/scip_timing.jl +++ b/src/wrapper/scip_timing.jl @@ -3,73 +3,73 @@ function SCIPgetTimeOfDay(scip) - ccall((:SCIPgetTimeOfDay, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetTimeOfDay, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPcreateClock(scip, clck) - ccall((:SCIPcreateClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) + ccall((:SCIPcreateClock, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) end function SCIPcreateCPUClock(scip, clck) - ccall((:SCIPcreateCPUClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) + ccall((:SCIPcreateCPUClock, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) end function SCIPcreateWallClock(scip, clck) - ccall((:SCIPcreateWallClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) + ccall((:SCIPcreateWallClock, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) end function SCIPfreeClock(scip, clck) - ccall((:SCIPfreeClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) + ccall((:SCIPfreeClock, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) end function SCIPresetClock(scip, clck) - ccall((:SCIPresetClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) + ccall((:SCIPresetClock, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CLOCK}), scip, clck) end function SCIPstartClock(scip, clck) - ccall((:SCIPstartClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) + ccall((:SCIPstartClock, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CLOCK}), scip, clck) end function SCIPstopClock(scip, clck) - ccall((:SCIPstopClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) + ccall((:SCIPstopClock, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CLOCK}), scip, clck) end function SCIPenableOrDisableStatisticTiming(scip) - ccall((:SCIPenableOrDisableStatisticTiming, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPenableOrDisableStatisticTiming, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPstartSolvingTime(scip) - ccall((:SCIPstartSolvingTime, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPstartSolvingTime, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPstopSolvingTime(scip) - ccall((:SCIPstopSolvingTime, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPstopSolvingTime, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPgetClockTime(scip, clck) - ccall((:SCIPgetClockTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) + ccall((:SCIPgetClockTime, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CLOCK}), scip, clck) end function SCIPsetClockTime(scip, clck, sec) - ccall((:SCIPsetClockTime, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}, Cdouble), scip, clck, sec) + ccall((:SCIPsetClockTime, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CLOCK}, Cdouble), scip, clck, sec) end function SCIPgetTotalTime(scip) - ccall((:SCIPgetTotalTime, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetTotalTime, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetSolvingTime(scip) - ccall((:SCIPgetSolvingTime, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetSolvingTime, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetReadingTime(scip) - ccall((:SCIPgetReadingTime, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetReadingTime, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetPresolvingTime(scip) - ccall((:SCIPgetPresolvingTime, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetPresolvingTime, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPgetFirstLPTime(scip) - ccall((:SCIPgetFirstLPTime, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetFirstLPTime, libscip), Cdouble, (Ptr{SCIP_},), scip) end diff --git a/src/wrapper/scip_tree.jl b/src/wrapper/scip_tree.jl index cebf5fe2..ee8b137a 100644 --- a/src/wrapper/scip_tree.jl +++ b/src/wrapper/scip_tree.jl @@ -3,117 +3,117 @@ function SCIPgetFocusNode(scip) - ccall((:SCIPgetFocusNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetFocusNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetCurrentNode(scip) - ccall((:SCIPgetCurrentNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetCurrentNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetDepth(scip) - ccall((:SCIPgetDepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetDepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetFocusDepth(scip) - ccall((:SCIPgetFocusDepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetFocusDepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetPlungeDepth(scip) - ccall((:SCIPgetPlungeDepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetPlungeDepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetRootNode(scip) - ccall((:SCIPgetRootNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetRootNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetEffectiveRootDepth(scip) - ccall((:SCIPgetEffectiveRootDepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetEffectiveRootDepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPinRepropagation(scip) - ccall((:SCIPinRepropagation, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPinRepropagation, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPgetChildren(scip, children, nchildren) - ccall((:SCIPgetChildren, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, children, nchildren) + ccall((:SCIPgetChildren, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, children, nchildren) end function SCIPgetNChildren(scip) - ccall((:SCIPgetNChildren, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNChildren, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetSiblings(scip, siblings, nsiblings) - ccall((:SCIPgetSiblings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, siblings, nsiblings) + ccall((:SCIPgetSiblings, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, siblings, nsiblings) end function SCIPgetNSiblings(scip) - ccall((:SCIPgetNSiblings, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNSiblings, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetLeaves(scip, leaves, nleaves) - ccall((:SCIPgetLeaves, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, leaves, nleaves) + ccall((:SCIPgetLeaves, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, leaves, nleaves) end function SCIPgetNLeaves(scip) - ccall((:SCIPgetNLeaves, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNLeaves, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNNodesLeft(scip) - ccall((:SCIPgetNNodesLeft, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNNodesLeft, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetPrioChild(scip) - ccall((:SCIPgetPrioChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetPrioChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetPrioSibling(scip) - ccall((:SCIPgetPrioSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetPrioSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetBestChild(scip) - ccall((:SCIPgetBestChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetBestChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetBestSibling(scip) - ccall((:SCIPgetBestSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetBestSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetBestLeaf(scip) - ccall((:SCIPgetBestLeaf, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetBestLeaf, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetBestNode(scip) - ccall((:SCIPgetBestNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetBestNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetBestboundNode(scip) - ccall((:SCIPgetBestboundNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP},), scip) + ccall((:SCIPgetBestboundNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_},), scip) end function SCIPgetOpenNodesData(scip, leaves, children, siblings, nleaves, nchildren, nsiblings) - ccall((:SCIPgetOpenNodesData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, leaves, children, siblings, nleaves, nchildren, nsiblings) + ccall((:SCIPgetOpenNodesData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, leaves, children, siblings, nleaves, nchildren, nsiblings) end function SCIPcutoffNode(scip, node) - ccall((:SCIPcutoffNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall((:SCIPcutoffNode, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}), scip, node) end function SCIPrepropagateNode(scip, node) - ccall((:SCIPrepropagateNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall((:SCIPrepropagateNode, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}), scip, node) end function SCIPgetCutoffdepth(scip) - ccall((:SCIPgetCutoffdepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetCutoffdepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetRepropdepth(scip) - ccall((:SCIPgetRepropdepth, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetRepropdepth, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPprintNodeRootPath(scip, node, file) - ccall((:SCIPprintNodeRootPath, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{FILE}), scip, node, file) + ccall((:SCIPprintNodeRootPath, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{FILE}), scip, node, file) end function SCIPsetFocusnodeLP(scip, solvelp) - ccall((:SCIPsetFocusnodeLP, libscip), Cvoid, (Ptr{SCIP}, UInt32), scip, solvelp) + ccall((:SCIPsetFocusnodeLP, libscip), Cvoid, (Ptr{SCIP_}, UInt32), scip, solvelp) end diff --git a/src/wrapper/scip_validation.jl b/src/wrapper/scip_validation.jl index 0258b24e..7fb13a1f 100644 --- a/src/wrapper/scip_validation.jl +++ b/src/wrapper/scip_validation.jl @@ -3,5 +3,5 @@ function SCIPvalidateSolve(scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) - ccall((:SCIPvalidateSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) + ccall((:SCIPvalidateSolve, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cdouble, Cdouble, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) end diff --git a/src/wrapper/scip_var.jl b/src/wrapper/scip_var.jl index 90f2dc54..07fbde15 100644 --- a/src/wrapper/scip_var.jl +++ b/src/wrapper/scip_var.jl @@ -3,661 +3,661 @@ function SCIPcreateVar(scip, var, name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) - ccall((:SCIPcreateVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}), scip, var, name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) + ccall((:SCIPcreateVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}), scip, var, name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) end function SCIPcreateVarBasic(scip, var, name, lb, ub, obj, vartype) - ccall((:SCIPcreateVarBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE), scip, var, name, lb, ub, obj, vartype) + ccall((:SCIPcreateVarBasic, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Cstring, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE), scip, var, name, lb, ub, obj, vartype) end function SCIPwriteVarName(scip, file, var, type) - ccall((:SCIPwriteVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{SCIP_VAR}, UInt32), scip, file, var, type) + ccall((:SCIPwriteVarName, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, Ptr{SCIP_VAR}, UInt32), scip, file, var, type) end function SCIPwriteVarsList(scip, file, vars, nvars, type, delimiter) - ccall((:SCIPwriteVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt8), scip, file, vars, nvars, type, delimiter) + ccall((:SCIPwriteVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32, UInt8), scip, file, vars, nvars, type, delimiter) end function SCIPwriteVarsLinearsum(scip, file, vars, vals, nvars, type) - ccall((:SCIPwriteVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), scip, file, vars, vals, nvars, type) + ccall((:SCIPwriteVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, UInt32), scip, file, vars, vals, nvars, type) end function SCIPwriteVarsPolynomial(scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, type) - ccall((:SCIPwriteVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{FILE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}, Cint, UInt32), scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, type) + ccall((:SCIPwriteVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{FILE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}, Cint, UInt32), scip, file, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, type) end function SCIPparseVar(scip, var, str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) - ccall((:SCIPparseVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cstring, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}, Ptr{Cstring}, Ptr{UInt32}), scip, var, str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) + ccall((:SCIPparseVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Cstring, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}, Ptr{Cstring}, Ptr{UInt32}), scip, var, str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) end function SCIPparseVarName(scip, str, var, endptr) - ccall((:SCIPparseVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cstring}), scip, str, var, endptr) + ccall((:SCIPparseVarName, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cstring}), scip, str, var, endptr) end function SCIPparseVarsList(scip, str, vars, nvars, varssize, requiredsize, endptr, delimiter, success) - ccall((:SCIPparseVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cstring}, UInt8, Ptr{UInt32}), scip, str, vars, nvars, varssize, requiredsize, endptr, delimiter, success) + ccall((:SCIPparseVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cstring}, UInt8, Ptr{UInt32}), scip, str, vars, nvars, varssize, requiredsize, endptr, delimiter, success) end function SCIPparseVarsLinearsum(scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) - ccall((:SCIPparseVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cstring}, Ptr{UInt32}), scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) + ccall((:SCIPparseVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cstring}, Ptr{UInt32}), scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) end function SCIPparseVarsPolynomial(scip, str, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, endptr, success) - ccall((:SCIPparseVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cstring}, Ptr{UInt32}), scip, str, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, endptr, success) + ccall((:SCIPparseVarsPolynomial, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cstring}, Ptr{UInt32}), scip, str, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, endptr, success) end function SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials) - ccall((:SCIPfreeParseVarsPolynomialData, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Cint), scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials) + ccall((:SCIPfreeParseVarsPolynomialData, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Cint), scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials) end function SCIPcaptureVar(scip, var) - ccall((:SCIPcaptureVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPcaptureVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPreleaseVar(scip, var) - ccall((:SCIPreleaseVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}), scip, var) + ccall((:SCIPreleaseVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}), scip, var) end function SCIPchgVarName(scip, var, name) - ccall((:SCIPchgVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cstring), scip, var, name) + ccall((:SCIPchgVarName, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cstring), scip, var, name) end function SCIPtransformVar(scip, var, transvar) - ccall((:SCIPtransformVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) + ccall((:SCIPtransformVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) end function SCIPtransformVars(scip, nvars, vars, transvars) - ccall((:SCIPtransformVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) + ccall((:SCIPtransformVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) end function SCIPgetTransformedVar(scip, var, transvar) - ccall((:SCIPgetTransformedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) + ccall((:SCIPgetTransformedVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) end function SCIPgetTransformedVars(scip, nvars, vars, transvars) - ccall((:SCIPgetTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) + ccall((:SCIPgetTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) end function SCIPgetNegatedVar(scip, var, negvar) - ccall((:SCIPgetNegatedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, negvar) + ccall((:SCIPgetNegatedVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, negvar) end function SCIPgetNegatedVars(scip, nvars, vars, negvars) - ccall((:SCIPgetNegatedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, negvars) + ccall((:SCIPgetNegatedVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, negvars) end function SCIPgetBinvarRepresentative(scip, var, repvar, negated) - ccall((:SCIPgetBinvarRepresentative, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), scip, var, repvar, negated) + ccall((:SCIPgetBinvarRepresentative, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), scip, var, repvar, negated) end function SCIPgetBinvarRepresentatives(scip, nvars, vars, repvars, negated) - ccall((:SCIPgetBinvarRepresentatives, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), scip, nvars, vars, repvars, negated) + ccall((:SCIPgetBinvarRepresentatives, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), scip, nvars, vars, repvars, negated) end function SCIPflattenVarAggregationGraph(scip, var) - ccall((:SCIPflattenVarAggregationGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPflattenVarAggregationGraph, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetProbvarLinearSum(scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) - ccall((:SCIPgetProbvarLinearSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cdouble}, Ptr{Cint}, UInt32), scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) + ccall((:SCIPgetProbvarLinearSum, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cdouble}, Ptr{Cint}, UInt32), scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) end function SCIPgetProbvarSum(scip, var, scalar, constant) - ccall((:SCIPgetProbvarSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, scalar, constant) + ccall((:SCIPgetProbvarSum, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, scalar, constant) end function SCIPgetActiveVars(scip, vars, nvars, varssize, requiredsize) - ccall((:SCIPgetActiveVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}), scip, vars, nvars, varssize, requiredsize) + ccall((:SCIPgetActiveVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}), scip, vars, nvars, varssize, requiredsize) end function SCIPgetVarRedcost(scip, var) - ccall((:SCIPgetVarRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarRedcost, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarImplRedcost(scip, var, varfixing) - ccall((:SCIPgetVarImplRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32), scip, var, varfixing) + ccall((:SCIPgetVarImplRedcost, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, UInt32), scip, var, varfixing) end function SCIPgetVarFarkasCoef(scip, var) - ccall((:SCIPgetVarFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarFarkasCoef, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarLbAtIndex(scip, var, bdchgidx, after) - ccall((:SCIPgetVarLbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) + ccall((:SCIPgetVarLbAtIndex, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) end function SCIPgetVarUbAtIndex(scip, var, bdchgidx, after) - ccall((:SCIPgetVarUbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) + ccall((:SCIPgetVarUbAtIndex, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) end function SCIPgetVarBdAtIndex(scip, var, boundtype, bdchgidx, after) - ccall((:SCIPgetVarBdAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, boundtype, bdchgidx, after) + ccall((:SCIPgetVarBdAtIndex, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, boundtype, bdchgidx, after) end function SCIPgetVarWasFixedAtIndex(scip, var, bdchgidx, after) - ccall((:SCIPgetVarWasFixedAtIndex, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) + ccall((:SCIPgetVarWasFixedAtIndex, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), scip, var, bdchgidx, after) end function SCIPgetVarSol(scip, var) - ccall((:SCIPgetVarSol, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarSol, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarSols(scip, nvars, vars, vals) - ccall((:SCIPgetVarSols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nvars, vars, vals) + ccall((:SCIPgetVarSols, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nvars, vars, vals) end function SCIPclearRelaxSolVals(scip) - ccall((:SCIPclearRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPclearRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPsetRelaxSolVal(scip, var, val) - ccall((:SCIPsetRelaxSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, val) + ccall((:SCIPsetRelaxSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, val) end function SCIPsetRelaxSolVals(scip, nvars, vars, vals, includeslp) - ccall((:SCIPsetRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, UInt32), scip, nvars, vars, vals, includeslp) + ccall((:SCIPsetRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, UInt32), scip, nvars, vars, vals, includeslp) end function SCIPsetRelaxSolValsSol(scip, sol, includeslp) - ccall((:SCIPsetRelaxSolValsSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, UInt32), scip, sol, includeslp) + ccall((:SCIPsetRelaxSolValsSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_SOL}, UInt32), scip, sol, includeslp) end function SCIPisRelaxSolValid(scip) - ccall((:SCIPisRelaxSolValid, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPisRelaxSolValid, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPmarkRelaxSolValid(scip, includeslp) - ccall((:SCIPmarkRelaxSolValid, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, includeslp) + ccall((:SCIPmarkRelaxSolValid, libscip), SCIP_RETCODE, (Ptr{SCIP_}, UInt32), scip, includeslp) end function SCIPmarkRelaxSolInvalid(scip) - ccall((:SCIPmarkRelaxSolInvalid, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPmarkRelaxSolInvalid, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPgetRelaxSolVal(scip, var) - ccall((:SCIPgetRelaxSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetRelaxSolVal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetRelaxSolObj(scip) - ccall((:SCIPgetRelaxSolObj, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall((:SCIPgetRelaxSolObj, libscip), Cdouble, (Ptr{SCIP_},), scip) end function SCIPisStrongbranchDownFirst(scip, var) - ccall((:SCIPisStrongbranchDownFirst, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPisStrongbranchDownFirst, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPstartStrongbranch(scip, enablepropagation) - ccall((:SCIPstartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP}, UInt32), scip, enablepropagation) + ccall((:SCIPstartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_}, UInt32), scip, enablepropagation) end function SCIPendStrongbranch(scip) - ccall((:SCIPendStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall((:SCIPendStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) end function SCIPgetVarStrongbranchFrac(scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) - ccall((:SCIPgetVarStrongbranchFrac, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarStrongbranchFrac, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) end function SCIPgetVarStrongbranchWithPropagation(scip, var, solval, lpobjval, itlim, maxproprounds, down, up, downvalid, upvalid, ndomredsdown, ndomredsup, downinf, upinf, downconflict, upconflict, lperror, newlbs, newubs) - ccall((:SCIPgetVarStrongbranchWithPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Clonglong}, Ptr{Clonglong}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, solval, lpobjval, itlim, maxproprounds, down, up, downvalid, upvalid, ndomredsdown, ndomredsup, downinf, upinf, downconflict, upconflict, lperror, newlbs, newubs) + ccall((:SCIPgetVarStrongbranchWithPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Clonglong}, Ptr{Clonglong}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, solval, lpobjval, itlim, maxproprounds, down, up, downvalid, upvalid, ndomredsdown, ndomredsup, downinf, upinf, downconflict, upconflict, lperror, newlbs, newubs) end function SCIPgetVarStrongbranchInt(scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) - ccall((:SCIPgetVarStrongbranchInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarStrongbranchInt, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, var, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) end function SCIPgetVarsStrongbranchesFrac(scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) - ccall((:SCIPgetVarsStrongbranchesFrac, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarsStrongbranchesFrac, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) end function SCIPgetVarsStrongbranchesInt(scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) - ccall((:SCIPgetVarsStrongbranchesInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarsStrongbranchesInt, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) end function SCIPgetLastStrongbranchLPSolStat(scip, branchdir) - ccall((:SCIPgetLastStrongbranchLPSolStat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, branchdir) + ccall((:SCIPgetLastStrongbranchLPSolStat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP_}, SCIP_BRANCHDIR), scip, branchdir) end function SCIPgetVarStrongbranchLast(scip, var, down, up, downvalid, upvalid, solval, lpobjval) - ccall((:SCIPgetVarStrongbranchLast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, down, up, downvalid, upvalid, solval, lpobjval) + ccall((:SCIPgetVarStrongbranchLast, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, down, up, downvalid, upvalid, solval, lpobjval) end function SCIPsetVarStrongbranchData(scip, var, lpobjval, primsol, down, up, downvalid, upvalid, iter, itlim) - ccall((:SCIPsetVarStrongbranchData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, UInt32, Clonglong, Cint), scip, var, lpobjval, primsol, down, up, downvalid, upvalid, iter, itlim) + ccall((:SCIPsetVarStrongbranchData, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, UInt32, UInt32, Clonglong, Cint), scip, var, lpobjval, primsol, down, up, downvalid, upvalid, iter, itlim) end function SCIPtryStrongbranchLPSol(scip, foundsol, cutoff) - ccall((:SCIPtryStrongbranchLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}, Ptr{UInt32}), scip, foundsol, cutoff) + ccall((:SCIPtryStrongbranchLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{UInt32}, Ptr{UInt32}), scip, foundsol, cutoff) end function SCIPgetVarStrongbranchNode(scip, var) - ccall((:SCIPgetVarStrongbranchNode, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarStrongbranchNode, libscip), Clonglong, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarStrongbranchLPAge(scip, var) - ccall((:SCIPgetVarStrongbranchLPAge, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarStrongbranchLPAge, libscip), Clonglong, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarNStrongbranchs(scip, var) - ccall((:SCIPgetVarNStrongbranchs, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarNStrongbranchs, libscip), Cint, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPaddVarLocksType(scip, var, locktype, nlocksdown, nlocksup) - ccall((:SCIPaddVarLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_LOCKTYPE, Cint, Cint), scip, var, locktype, nlocksdown, nlocksup) + ccall((:SCIPaddVarLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_LOCKTYPE, Cint, Cint), scip, var, locktype, nlocksdown, nlocksup) end function SCIPaddVarLocks(scip, var, nlocksdown, nlocksup) - ccall((:SCIPaddVarLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cint), scip, var, nlocksdown, nlocksup) + ccall((:SCIPaddVarLocks, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint, Cint), scip, var, nlocksdown, nlocksup) end function SCIPlockVarCons(scip, var, cons, lockdown, lockup) - ccall((:SCIPlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32), scip, var, cons, lockdown, lockup) + ccall((:SCIPlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32), scip, var, cons, lockdown, lockup) end function SCIPunlockVarCons(scip, var, cons, lockdown, lockup) - ccall((:SCIPunlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32), scip, var, cons, lockdown, lockup) + ccall((:SCIPunlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, UInt32, UInt32), scip, var, cons, lockdown, lockup) end function SCIPchgVarObj(scip, var, newobj) - ccall((:SCIPchgVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) + ccall((:SCIPchgVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end function SCIPaddVarObj(scip, var, addobj) - ccall((:SCIPaddVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addobj) + ccall((:SCIPaddVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, addobj) end function SCIPadjustedVarLb(scip, var, lb) - ccall((:SCIPadjustedVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lb) + ccall((:SCIPadjustedVarLb, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, lb) end function SCIPadjustedVarUb(scip, var, ub) - ccall((:SCIPadjustedVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, ub) + ccall((:SCIPadjustedVarUb, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, ub) end function SCIPchgVarLb(scip, var, newbound) - ccall((:SCIPchgVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall((:SCIPchgVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarUb(scip, var, newbound) - ccall((:SCIPchgVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall((:SCIPchgVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarLbNode(scip, node, var, newbound) - ccall((:SCIPchgVarLbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) + ccall((:SCIPchgVarLbNode, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) end function SCIPchgVarUbNode(scip, node, var, newbound) - ccall((:SCIPchgVarUbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) + ccall((:SCIPchgVarUbNode, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) end function SCIPchgVarLbGlobal(scip, var, newbound) - ccall((:SCIPchgVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall((:SCIPchgVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarUbGlobal(scip, var, newbound) - ccall((:SCIPchgVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall((:SCIPchgVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarLbLazy(scip, var, lazylb) - ccall((:SCIPchgVarLbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazylb) + ccall((:SCIPchgVarLbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazylb) end function SCIPchgVarUbLazy(scip, var, lazyub) - ccall((:SCIPchgVarUbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazyub) + ccall((:SCIPchgVarUbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazyub) end function SCIPtightenVarLb(scip, var, newbound, force, infeasible, tightened) - ccall((:SCIPtightenVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) + ccall((:SCIPtightenVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) end function SCIPtightenVarUb(scip, var, newbound, force, infeasible, tightened) - ccall((:SCIPtightenVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) + ccall((:SCIPtightenVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) end function SCIPinferVarFixCons(scip, var, fixedval, infercons, inferinfo, force, infeasible, tightened) - ccall((:SCIPinferVarFixCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infercons, inferinfo, force, infeasible, tightened) + ccall((:SCIPinferVarFixCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infercons, inferinfo, force, infeasible, tightened) end function SCIPinferVarLbCons(scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) - ccall((:SCIPinferVarLbCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) + ccall((:SCIPinferVarLbCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) end function SCIPinferVarUbCons(scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) - ccall((:SCIPinferVarUbCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) + ccall((:SCIPinferVarUbCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_CONS}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, infercons, inferinfo, force, infeasible, tightened) end function SCIPinferBinvarCons(scip, var, fixedval, infercons, inferinfo, infeasible, tightened) - ccall((:SCIPinferBinvarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_CONS}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infercons, inferinfo, infeasible, tightened) + ccall((:SCIPinferBinvarCons, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_CONS}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infercons, inferinfo, infeasible, tightened) end function SCIPinferVarFixProp(scip, var, fixedval, inferprop, inferinfo, force, infeasible, tightened) - ccall((:SCIPinferVarFixProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, inferprop, inferinfo, force, infeasible, tightened) + ccall((:SCIPinferVarFixProp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, inferprop, inferinfo, force, infeasible, tightened) end function SCIPinferVarLbProp(scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) - ccall((:SCIPinferVarLbProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) + ccall((:SCIPinferVarLbProp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) end function SCIPinferVarUbProp(scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) - ccall((:SCIPinferVarUbProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) + ccall((:SCIPinferVarUbProp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_PROP}, Cint, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, inferprop, inferinfo, force, infeasible, tightened) end function SCIPinferBinvarProp(scip, var, fixedval, inferprop, inferinfo, infeasible, tightened) - ccall((:SCIPinferBinvarProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_PROP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, inferprop, inferinfo, infeasible, tightened) + ccall((:SCIPinferBinvarProp, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_PROP}, Cint, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, inferprop, inferinfo, infeasible, tightened) end function SCIPtightenVarLbGlobal(scip, var, newbound, force, infeasible, tightened) - ccall((:SCIPtightenVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) + ccall((:SCIPtightenVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) end function SCIPtightenVarUbGlobal(scip, var, newbound, force, infeasible, tightened) - ccall((:SCIPtightenVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) + ccall((:SCIPtightenVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, UInt32, Ptr{UInt32}, Ptr{UInt32}), scip, var, newbound, force, infeasible, tightened) end function SCIPcomputeVarLbGlobal(scip, var) - ccall((:SCIPcomputeVarLbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPcomputeVarLbGlobal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPcomputeVarUbGlobal(scip, var) - ccall((:SCIPcomputeVarUbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPcomputeVarUbGlobal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPcomputeVarLbLocal(scip, var) - ccall((:SCIPcomputeVarLbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPcomputeVarLbLocal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPcomputeVarUbLocal(scip, var) - ccall((:SCIPcomputeVarUbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPcomputeVarUbLocal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarMultaggrLbGlobal(scip, var) - ccall((:SCIPgetVarMultaggrLbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarMultaggrLbGlobal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarMultaggrUbGlobal(scip, var) - ccall((:SCIPgetVarMultaggrUbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarMultaggrUbGlobal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarMultaggrLbLocal(scip, var) - ccall((:SCIPgetVarMultaggrLbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarMultaggrLbLocal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarMultaggrUbLocal(scip, var) - ccall((:SCIPgetVarMultaggrUbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarMultaggrUbLocal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarClosestVlb(scip, var, sol, closestvlb, closestvlbidx) - ccall((:SCIPgetVarClosestVlb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvlb, closestvlbidx) + ccall((:SCIPgetVarClosestVlb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvlb, closestvlbidx) end function SCIPgetVarClosestVub(scip, var, sol, closestvub, closestvubidx) - ccall((:SCIPgetVarClosestVub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvub, closestvubidx) + ccall((:SCIPgetVarClosestVub, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvub, closestvubidx) end function SCIPaddVarVlb(scip, var, vlbvar, vlbcoef, vlbconstant, infeasible, nbdchgs) - ccall((:SCIPaddVarVlb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, vlbvar, vlbcoef, vlbconstant, infeasible, nbdchgs) + ccall((:SCIPaddVarVlb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, vlbvar, vlbcoef, vlbconstant, infeasible, nbdchgs) end function SCIPaddVarVub(scip, var, vubvar, vubcoef, vubconstant, infeasible, nbdchgs) - ccall((:SCIPaddVarVub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, vubvar, vubcoef, vubconstant, infeasible, nbdchgs) + ccall((:SCIPaddVarVub, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, vubvar, vubcoef, vubconstant, infeasible, nbdchgs) end function SCIPaddVarImplication(scip, var, varfixing, implvar, impltype, implbound, infeasible, nbdchgs) - ccall((:SCIPaddVarImplication, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, varfixing, implvar, impltype, implbound, infeasible, nbdchgs) + ccall((:SCIPaddVarImplication, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Cdouble, Ptr{UInt32}, Ptr{Cint}), scip, var, varfixing, implvar, impltype, implbound, infeasible, nbdchgs) end function SCIPaddClique(scip, vars, values, nvars, isequation, infeasible, nbdchgs) - ccall((:SCIPaddClique, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}, Cint, UInt32, Ptr{UInt32}, Ptr{Cint}), scip, vars, values, nvars, isequation, infeasible, nbdchgs) + ccall((:SCIPaddClique, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}, Cint, UInt32, Ptr{UInt32}, Ptr{Cint}), scip, vars, values, nvars, isequation, infeasible, nbdchgs) end function SCIPcalcCliquePartition(scip, vars, nvars, cliquepartition, ncliques) - ccall((:SCIPcalcCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, cliquepartition, ncliques) + ccall((:SCIPcalcCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, cliquepartition, ncliques) end function SCIPcalcNegatedCliquePartition(scip, vars, nvars, cliquepartition, ncliques) - ccall((:SCIPcalcNegatedCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, cliquepartition, ncliques) + ccall((:SCIPcalcNegatedCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, cliquepartition, ncliques) end function SCIPcleanupCliques(scip, infeasible) - ccall((:SCIPcleanupCliques, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{UInt32}), scip, infeasible) + ccall((:SCIPcleanupCliques, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{UInt32}), scip, infeasible) end function SCIPgetNCliques(scip) - ccall((:SCIPgetNCliques, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNCliques, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetNCliquesCreated(scip) - ccall((:SCIPgetNCliquesCreated, libscip), Cint, (Ptr{SCIP},), scip) + ccall((:SCIPgetNCliquesCreated, libscip), Cint, (Ptr{SCIP_},), scip) end function SCIPgetCliques(scip) - ccall((:SCIPgetCliques, libscip), Ptr{Ptr{SCIP_CLIQUE}}, (Ptr{SCIP},), scip) + ccall((:SCIPgetCliques, libscip), Ptr{Ptr{SCIP_CLIQUE}}, (Ptr{SCIP_},), scip) end function SCIPhaveVarsCommonClique(scip, var1, value1, var2, value2, regardimplics) - ccall((:SCIPhaveVarsCommonClique, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, UInt32, UInt32), scip, var1, value1, var2, value2, regardimplics) + ccall((:SCIPhaveVarsCommonClique, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, UInt32, UInt32), scip, var1, value1, var2, value2, regardimplics) end function SCIPwriteCliqueGraph(scip, fname, writenodeweights) - ccall((:SCIPwriteCliqueGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cstring, UInt32), scip, fname, writenodeweights) + ccall((:SCIPwriteCliqueGraph, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Cstring, UInt32), scip, fname, writenodeweights) end function SCIPremoveVarFromGlobalStructures(scip, var) - ccall((:SCIPremoveVarFromGlobalStructures, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPremoveVarFromGlobalStructures, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPchgVarBranchFactor(scip, var, branchfactor) - ccall((:SCIPchgVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, branchfactor) + ccall((:SCIPchgVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, branchfactor) end function SCIPscaleVarBranchFactor(scip, var, scale) - ccall((:SCIPscaleVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, scale) + ccall((:SCIPscaleVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, scale) end function SCIPaddVarBranchFactor(scip, var, addfactor) - ccall((:SCIPaddVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addfactor) + ccall((:SCIPaddVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, addfactor) end function SCIPchgVarBranchPriority(scip, var, branchpriority) - ccall((:SCIPchgVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) + ccall((:SCIPchgVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) end function SCIPupdateVarBranchPriority(scip, var, branchpriority) - ccall((:SCIPupdateVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) + ccall((:SCIPupdateVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) end function SCIPaddVarBranchPriority(scip, var, addpriority) - ccall((:SCIPaddVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, addpriority) + ccall((:SCIPaddVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint), scip, var, addpriority) end function SCIPchgVarBranchDirection(scip, var, branchdirection) - ccall((:SCIPchgVarBranchDirection, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, branchdirection) + ccall((:SCIPchgVarBranchDirection, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, branchdirection) end function SCIPchgVarType(scip, var, vartype, infeasible) - ccall((:SCIPchgVarType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_VARTYPE, Ptr{UInt32}), scip, var, vartype, infeasible) + ccall((:SCIPchgVarType, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_VARTYPE, Ptr{UInt32}), scip, var, vartype, infeasible) end function SCIPfixVar(scip, var, fixedval, infeasible, fixed) - ccall((:SCIPfixVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infeasible, fixed) + ccall((:SCIPfixVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{UInt32}, Ptr{UInt32}), scip, var, fixedval, infeasible, fixed) end function SCIPaggregateVars(scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) - ccall((:SCIPaggregateVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) + ccall((:SCIPaggregateVars, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Ptr{UInt32}, Ptr{UInt32}, Ptr{UInt32}), scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) end function SCIPmultiaggregateVar(scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) - ccall((:SCIPmultiaggregateVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Ptr{UInt32}, Ptr{UInt32}), scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) + ccall((:SCIPmultiaggregateVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Ptr{UInt32}, Ptr{UInt32}), scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) end function SCIPdoNotAggr(scip) - ccall((:SCIPdoNotAggr, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPdoNotAggr, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPdoNotMultaggr(scip) - ccall((:SCIPdoNotMultaggr, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPdoNotMultaggr, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPdoNotMultaggrVar(scip, var) - ccall((:SCIPdoNotMultaggrVar, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPdoNotMultaggrVar, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPallowDualReds(scip) - ccall((:SCIPallowDualReds, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPallowDualReds, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPallowObjProp(scip) - ccall((:SCIPallowObjProp, libscip), UInt32, (Ptr{SCIP},), scip) + ccall((:SCIPallowObjProp, libscip), UInt32, (Ptr{SCIP_},), scip) end function SCIPmarkDoNotMultaggrVar(scip, var) - ccall((:SCIPmarkDoNotMultaggrVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPmarkDoNotMultaggrVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPenableVarHistory(scip) - ccall((:SCIPenableVarHistory, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPenableVarHistory, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPdisableVarHistory(scip) - ccall((:SCIPdisableVarHistory, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall((:SCIPdisableVarHistory, libscip), Cvoid, (Ptr{SCIP_},), scip) end function SCIPupdateVarPseudocost(scip, var, solvaldelta, objdelta, weight) - ccall((:SCIPupdateVarPseudocost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, var, solvaldelta, objdelta, weight) + ccall((:SCIPupdateVarPseudocost, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, var, solvaldelta, objdelta, weight) end function SCIPgetVarPseudocostVal(scip, var, solvaldelta) - ccall((:SCIPgetVarPseudocostVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) + ccall((:SCIPgetVarPseudocostVal, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) end function SCIPgetVarPseudocostValCurrentRun(scip, var, solvaldelta) - ccall((:SCIPgetVarPseudocostValCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) + ccall((:SCIPgetVarPseudocostValCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) end function SCIPgetVarPseudocost(scip, var, dir) - ccall((:SCIPgetVarPseudocost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarPseudocost, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarPseudocostCurrentRun(scip, var, dir) - ccall((:SCIPgetVarPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarPseudocostCount(scip, var, dir) - ccall((:SCIPgetVarPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarPseudocostCount, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarPseudocostCountCurrentRun(scip, var, dir) - ccall((:SCIPgetVarPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarPseudocostVariance(scip, var, dir, onlycurrentrun) - ccall((:SCIPgetVarPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, UInt32), scip, var, dir, onlycurrentrun) + ccall((:SCIPgetVarPseudocostVariance, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, UInt32), scip, var, dir, onlycurrentrun) end function SCIPcalculatePscostConfidenceBound(scip, var, dir, onlycurrentrun, clevel) - ccall((:SCIPcalculatePscostConfidenceBound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, UInt32, SCIP_CONFIDENCELEVEL), scip, var, dir, onlycurrentrun, clevel) + ccall((:SCIPcalculatePscostConfidenceBound, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, UInt32, SCIP_CONFIDENCELEVEL), scip, var, dir, onlycurrentrun, clevel) end function SCIPsignificantVarPscostDifference(scip, varx, fracx, vary, fracy, dir, clevel, onesided) - ccall((:SCIPsignificantVarPscostDifference, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_VAR}, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL, UInt32), scip, varx, fracx, vary, fracy, dir, clevel, onesided) + ccall((:SCIPsignificantVarPscostDifference, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_VAR}, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL, UInt32), scip, varx, fracx, vary, fracy, dir, clevel, onesided) end function SCIPpscostThresholdProbabilityTest(scip, var, frac, threshold, dir, clevel) - ccall((:SCIPpscostThresholdProbabilityTest, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL), scip, var, frac, threshold, dir, clevel) + ccall((:SCIPpscostThresholdProbabilityTest, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL), scip, var, frac, threshold, dir, clevel) end function SCIPisVarPscostRelerrorReliable(scip, var, threshold, clevel) - ccall((:SCIPisVarPscostRelerrorReliable, libscip), UInt32, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, SCIP_CONFIDENCELEVEL), scip, var, threshold, clevel) + ccall((:SCIPisVarPscostRelerrorReliable, libscip), UInt32, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, SCIP_CONFIDENCELEVEL), scip, var, threshold, clevel) end function SCIPgetVarPseudocostScore(scip, var, solval) - ccall((:SCIPgetVarPseudocostScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) + ccall((:SCIPgetVarPseudocostScore, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) end function SCIPgetVarPseudocostScoreCurrentRun(scip, var, solval) - ccall((:SCIPgetVarPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) + ccall((:SCIPgetVarPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) end function SCIPgetVarVSIDS(scip, var, dir) - ccall((:SCIPgetVarVSIDS, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarVSIDS, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarVSIDSCurrentRun(scip, var, dir) - ccall((:SCIPgetVarVSIDSCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarVSIDSCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarConflictScore(scip, var) - ccall((:SCIPgetVarConflictScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarConflictScore, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarConflictScoreCurrentRun(scip, var) - ccall((:SCIPgetVarConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarConflictlengthScore(scip, var) - ccall((:SCIPgetVarConflictlengthScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarConflictlengthScore, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarConflictlengthScoreCurrentRun(scip, var) - ccall((:SCIPgetVarConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarAvgConflictlength(scip, var, dir) - ccall((:SCIPgetVarAvgConflictlength, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarAvgConflictlength, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgConflictlengthCurrentRun(scip, var, dir) - ccall((:SCIPgetVarAvgConflictlengthCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarAvgConflictlengthCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgInferences(scip, var, dir) - ccall((:SCIPgetVarAvgInferences, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarAvgInferences, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgInferencesCurrentRun(scip, var, dir) - ccall((:SCIPgetVarAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgInferenceScore(scip, var) - ccall((:SCIPgetVarAvgInferenceScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarAvgInferenceScore, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarAvgInferenceScoreCurrentRun(scip, var) - ccall((:SCIPgetVarAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPinitVarBranchStats(scip, var, downpscost, uppscost, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) - ccall((:SCIPinitVarBranchStats, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, var, downpscost, uppscost, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) + ccall((:SCIPinitVarBranchStats, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, var, downpscost, uppscost, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) end function SCIPinitVarValueBranchStats(scip, var, value, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) - ccall((:SCIPinitVarValueBranchStats, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, var, value, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) + ccall((:SCIPinitVarValueBranchStats, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, var, value, downvsids, upvsids, downconflen, upconflen, downinfer, upinfer, downcutoff, upcutoff) end function SCIPgetVarAvgCutoffs(scip, var, dir) - ccall((:SCIPgetVarAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarAvgCutoffs, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgCutoffsCurrentRun(scip, var, dir) - ccall((:SCIPgetVarAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall((:SCIPgetVarAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgCutoffScore(scip, var) - ccall((:SCIPgetVarAvgCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarAvgCutoffScore, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarAvgCutoffScoreCurrentRun(scip, var) - ccall((:SCIPgetVarAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall((:SCIPgetVarAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarAvgInferenceCutoffScore(scip, var, cutoffweight) - ccall((:SCIPgetVarAvgInferenceCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) + ccall((:SCIPgetVarAvgInferenceCutoffScore, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) end function SCIPgetVarAvgInferenceCutoffScoreCurrentRun(scip, var, cutoffweight) - ccall((:SCIPgetVarAvgInferenceCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) + ccall((:SCIPgetVarAvgInferenceCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) end function SCIPprintVar(scip, var, file) - ccall((:SCIPprintVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{FILE}), scip, var, file) + ccall((:SCIPprintVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{FILE}), scip, var, file) end From 8a3f94585238a3448656c84cacc6b46f8e870308 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 22:47:13 +0100 Subject: [PATCH 18/82] manually define FILE --- src/wrapper/manual_commons.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/wrapper/manual_commons.jl b/src/wrapper/manual_commons.jl index 345325ee..cdf84cdd 100644 --- a/src/wrapper/manual_commons.jl +++ b/src/wrapper/manual_commons.jl @@ -36,3 +36,5 @@ const SCIP_EVENTTYPE_ROWSIDECHANGED = UInt64(0x80000000) const SCIP_EVENTTYPE_SYNC = UInt64(0x100000000) const PRIx64 = "llx" + +const FILE = Cvoid From 31b995999a49488fae8d6852856190ed3438f737 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 22:57:09 +0100 Subject: [PATCH 19/82] include nlpi headers in generate_wrapper.jl --- gen/generate_wrapper.jl | 16 +++- src/wrapper/commons.jl | 181 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 193 insertions(+), 4 deletions(-) diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index fafb33e5..92270f7b 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -1,16 +1,24 @@ using Clang HEADER_BASE = "/usr/include" # using system-wide installation of SCIP -HEADER_DIR = "scip" -all_headers = readdir(joinpath(HEADER_BASE, HEADER_DIR)) -headers = vcat( +all_headers = readdir(joinpath(HEADER_BASE, "scip")) +scip_headers = vcat( filter(h -> startswith(h, "type_"), all_headers), # filter(h -> startswith(h, "pub_"), all_headers), filter(h -> startswith(h, "scip_"), all_headers), ) +nlpi_headers = [ + "type_expr.h", + "type_nlpi.h", +] + +headers = vcat( + [joinpath(HEADER_BASE, "scip", h) for h in scip_headers], + [joinpath(HEADER_BASE, "nlpi", h) for h in nlpi_headers], +) context = Clang.init( - headers=[joinpath(HEADER_BASE, HEADER_DIR, h) for h in headers], + headers=headers, common_file="commons.jl", output_dir="../src/wrapper", clang_includes=vcat(HEADER_BASE, LLVM_INCLUDE), diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index fdc03b3e..9378df55 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -1173,3 +1173,184 @@ const SCIP_VISUAL = SCIP_Visual # Skipping MacroDefinition: SCIPfreeCleanBufferArrayNull ( scip , ptr ) BMSfreeBufferMemoryArrayNull ( SCIPcleanbuffer ( scip ) , ( ptr ) ) # Skipping MacroDefinition: SCIPdebugMsg ( scip , ... ) while ( FALSE ) SCIPprintDebugMessage ( scip , __FILE__ , __LINE__ , __VA_ARGS__ ) # Skipping MacroDefinition: SCIPdebugMsgPrint ( scip , ... ) while ( FALSE ) SCIPdebugMessagePrint ( scip , __VA_ARGS__ ) + +const SCIP_EXPR_DEGREEINFINITY = 65535 + +# Skipping MacroDefinition: SCIP_DECL_EXPREVAL ( x ) SCIP_RETCODE x ( SCIP_EXPROPDATA opdata , int nargs , SCIP_Real * argvals , SCIP_Real * varvals , SCIP_Real * paramvals , SCIP_Real * result ) +# Skipping MacroDefinition: SCIP_DECL_EXPRINTEVAL ( x ) SCIP_RETCODE x ( SCIP_Real infinity , SCIP_EXPROPDATA opdata , int nargs , SCIP_INTERVAL * argvals , SCIP_INTERVAL * varvals , SCIP_Real * paramvals , SCIP_INTERVAL * result ) +# Skipping MacroDefinition: SCIP_DECL_EXPRCURV ( x ) SCIP_RETCODE x ( SCIP_Real infinity , SCIP_EXPROPDATA opdata , int nargs , SCIP_INTERVAL * argbounds , SCIP_EXPRCURV * argcurv , SCIP_EXPRCURV * result ) +# Skipping MacroDefinition: SCIP_DECL_EXPRCOPYDATA ( x ) SCIP_RETCODE x ( BMS_BLKMEM * blkmem , int nchildren , SCIP_EXPROPDATA opdatasource , SCIP_EXPROPDATA * opdatatarget ) +# Skipping MacroDefinition: SCIP_DECL_EXPRFREEDATA ( x ) void x ( BMS_BLKMEM * blkmem , int nchildren , SCIP_EXPROPDATA opdata ) +# Skipping MacroDefinition: SCIP_DECL_EXPRGRAPHVARADDED ( x ) SCIP_RETCODE x ( SCIP_EXPRGRAPH * exprgraph , void * userdata , void * var , SCIP_EXPRGRAPHNODE * varnode ) +# Skipping MacroDefinition: SCIP_DECL_EXPRGRAPHVARREMOVE ( x ) SCIP_RETCODE x ( SCIP_EXPRGRAPH * exprgraph , void * userdata , void * var , SCIP_EXPRGRAPHNODE * varnode ) +# Skipping MacroDefinition: SCIP_DECL_EXPRGRAPHVARCHGIDX ( x ) SCIP_RETCODE x ( SCIP_EXPRGRAPH * exprgraph , void * userdata , void * var , SCIP_EXPRGRAPHNODE * varnode , int oldidx , int newidx ) + +const SCIP_EXPRBOUNDSTATUS_VALID = 0x00 +const SCIP_EXPRBOUNDSTATUS_CHILDTIGHTENED = 0x01 +const SCIP_EXPRBOUNDSTATUS_CHILDRELAXED = 0x02 +const SCIP_EXPRBOUNDSTATUS_TIGHTENEDBYPARENT = 0x04 +const SCIP_EXPRBOUNDSTATUS_TIGHTENEDBYPARENTRECENT = 0x08 | SCIP_EXPRBOUNDSTATUS_TIGHTENEDBYPARENT +const SCIP_EXPRBOUNDSTATUS_TIGHTENEDBYPARENTFORCE = 0x10 | SCIP_EXPRBOUNDSTATUS_TIGHTENEDBYPARENTRECENT + +# Skipping MacroDefinition: SCIP_DECL_USEREXPRESTIMATE ( x ) SCIP_RETCODE x ( SCIP_Real infinity , SCIP_USEREXPRDATA * data , int nargs , SCIP_Real * argvals , SCIP_INTERVAL * argbounds , SCIP_Bool overestimate , SCIP_Real * coeffs , SCIP_Real * constant , SCIP_Bool * success ) +# Skipping MacroDefinition: SCIP_DECL_USEREXPREVAL ( x ) SCIP_RETCODE x ( SCIP_USEREXPRDATA * data , int nargs , SCIP_Real * argvals , SCIP_Real * funcvalue , SCIP_Real * gradient , SCIP_Real * hessian ) +# Skipping MacroDefinition: SCIP_DECL_USEREXPRINTEVAL ( x ) SCIP_RETCODE x ( SCIP_Real infinity , SCIP_USEREXPRDATA * data , int nargs , SCIP_INTERVAL * argvals , SCIP_INTERVAL * funcvalue , SCIP_INTERVAL * gradient , SCIP_INTERVAL * hessian ) +# Skipping MacroDefinition: SCIP_DECL_USEREXPRCURV ( x ) SCIP_RETCODE x ( SCIP_Real infinity , SCIP_USEREXPRDATA * data , int nargs , SCIP_INTERVAL * argbounds , SCIP_EXPRCURV * argcurv , SCIP_EXPRCURV * result ) +# Skipping MacroDefinition: SCIP_DECL_USEREXPRPROP ( x ) SCIP_RETCODE x ( SCIP_Real infinity , SCIP_USEREXPRDATA * data , int nargs , SCIP_INTERVAL * argbounds , SCIP_INTERVAL funcbounds , SCIP_Bool * cutoff ) +# Skipping MacroDefinition: SCIP_DECL_USEREXPRCOPYDATA ( x ) SCIP_RETCODE x ( BMS_BLKMEM * blkmem , int nchildren , SCIP_USEREXPRDATA * datasource , SCIP_USEREXPRDATA * * datatarget ) +# Skipping MacroDefinition: SCIP_DECL_USEREXPRFREEDATA ( x ) void x ( BMS_BLKMEM * blkmem , int nchildren , SCIP_USEREXPRDATA * data ) +# Skipping MacroDefinition: SCIP_DECL_USEREXPRPRINT ( x ) void x ( SCIP_USEREXPRDATA * data , SCIP_MESSAGEHDLR * messagehdlr , FILE * file ) + +@cenum(SCIP_ExprOp, + SCIP_EXPR_VARIDX = 1, + SCIP_EXPR_CONST = 2, + SCIP_EXPR_PARAM = 3, + SCIP_EXPR_PLUS = 8, + SCIP_EXPR_MINUS = 9, + SCIP_EXPR_MUL = 10, + SCIP_EXPR_DIV = 11, + SCIP_EXPR_SQUARE = 12, + SCIP_EXPR_SQRT = 13, + SCIP_EXPR_REALPOWER = 14, + SCIP_EXPR_INTPOWER = 15, + SCIP_EXPR_SIGNPOWER = 16, + SCIP_EXPR_EXP = 17, + SCIP_EXPR_LOG = 18, + SCIP_EXPR_SIN = 19, + SCIP_EXPR_COS = 20, + SCIP_EXPR_TAN = 21, + SCIP_EXPR_MIN = 24, + SCIP_EXPR_MAX = 25, + SCIP_EXPR_ABS = 26, + SCIP_EXPR_SIGN = 27, + SCIP_EXPR_SUM = 64, + SCIP_EXPR_PRODUCT = 65, + SCIP_EXPR_LINEAR = 66, + SCIP_EXPR_QUADRATIC = 67, + SCIP_EXPR_POLYNOMIAL = 68, + SCIP_EXPR_USER = 69, + SCIP_EXPR_LAST = 70, +) +@cenum(SCIP_ExprCurv, + SCIP_EXPRCURV_UNKNOWN = 0, + SCIP_EXPRCURV_CONVEX = 1, + SCIP_EXPRCURV_CONCAVE = 2, + SCIP_EXPRCURV_LINEAR = 3, +) + +const SCIP_EXPROP = SCIP_ExprOp +const SCIP_ExprOpData = Cvoid +const SCIP_EXPROPDATA = SCIP_ExprOpData +const SCIP_Expr = Cvoid +const SCIP_EXPR = SCIP_Expr +const SCIP_ExprTree = Cvoid +const SCIP_EXPRTREE = SCIP_ExprTree +const SCIP_EXPRCURV = SCIP_ExprCurv + +struct SCIP_QuadElement + idx1::Cint + idx2::Cint + coef::Cdouble +end + +const SCIP_QUADELEM = SCIP_QuadElement +const SCIP_ExprData_Quadratic = Cvoid +const SCIP_EXPRDATA_QUADRATIC = SCIP_ExprData_Quadratic +const SCIP_ExprData_Monomial = Cvoid +const SCIP_EXPRDATA_MONOMIAL = SCIP_ExprData_Monomial +const SCIP_ExprData_Polynomial = Cvoid +const SCIP_EXPRDATA_POLYNOMIAL = SCIP_ExprData_Polynomial +const SCIP_ExprData_User = Cvoid +const SCIP_EXPRDATA_USER = SCIP_ExprData_User +const SCIP_ExprGraphNode = Cvoid +const SCIP_EXPRGRAPHNODE = SCIP_ExprGraphNode +const SCIP_ExprGraph = Cvoid +const SCIP_EXPRGRAPH = SCIP_ExprGraph +const SCIP_EXPRBOUNDSTATUS = UInt8 +const SCIP_UserExprData = Cvoid +const SCIP_USEREXPRDATA = SCIP_UserExprData + +# Skipping MacroDefinition: SCIP_DECL_NLPICOPY ( x ) SCIP_RETCODE x ( BMS_BLKMEM * blkmem , SCIP_NLPI * sourcenlpi , SCIP_NLPI * * targetnlpi ) +# Skipping MacroDefinition: SCIP_DECL_NLPIFREE ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETSOLVERPOINTER ( x ) void * x ( SCIP_NLPI * nlpi ) +# Skipping MacroDefinition: SCIP_DECL_NLPICREATEPROBLEM ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * * problem , const char * name ) +# Skipping MacroDefinition: SCIP_DECL_NLPIFREEPROBLEM ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * * problem ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETPROBLEMPOINTER ( x ) void * x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem ) +# Skipping MacroDefinition: SCIP_DECL_NLPIADDVARS ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int nvars , const SCIP_Real * lbs , const SCIP_Real * ubs , const char * * varnames ) +# Skipping MacroDefinition: SCIP_DECL_NLPIADDCONSTRAINTS ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int ncons , const SCIP_Real * lhss , const SCIP_Real * rhss , const int * nlininds , int * const * lininds , SCIP_Real * const * linvals , const int * nquadelems , SCIP_QUADELEM * const * quadelems , int * const * exprvaridxs , SCIP_EXPRTREE * const * exprtrees , const char * * names ) +# Skipping MacroDefinition: SCIP_DECL_NLPISETOBJECTIVE ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int nlins , const int * lininds , const SCIP_Real * linvals , int nquadelems , const SCIP_QUADELEM * quadelems , const int * exprvaridxs , const SCIP_EXPRTREE * exprtree , const SCIP_Real constant ) +# Skipping MacroDefinition: SCIP_DECL_NLPICHGVARBOUNDS ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , const int nvars , const int * indices , const SCIP_Real * lbs , const SCIP_Real * ubs ) +# Skipping MacroDefinition: SCIP_DECL_NLPICHGCONSSIDES ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int nconss , const int * indices , const SCIP_Real * lhss , const SCIP_Real * rhss ) +# Skipping MacroDefinition: SCIP_DECL_NLPIDELVARSET ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int * dstats , int dstatssize ) +# Skipping MacroDefinition: SCIP_DECL_NLPIDELCONSSET ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int * dstats , int dstatssize ) +# Skipping MacroDefinition: SCIP_DECL_NLPICHGLINEARCOEFS ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int idx , int nvals , const int * varidxs , const SCIP_Real * vals ) +# Skipping MacroDefinition: SCIP_DECL_NLPICHGQUADCOEFS ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int idx , int nquadelems , const SCIP_QUADELEM * quadelems ) +# Skipping MacroDefinition: SCIP_DECL_NLPICHGEXPRTREE ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int idxcons , const int * exprvaridxs , const SCIP_EXPRTREE * exprtree ) +# Skipping MacroDefinition: SCIP_DECL_NLPICHGNONLINCOEF ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , int idxcons , int idxparam , SCIP_Real value ) +# Skipping MacroDefinition: SCIP_DECL_NLPICHGOBJCONSTANT ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_Real objconstant ) +# Skipping MacroDefinition: SCIP_DECL_NLPISETINITIALGUESS ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_Real * primalvalues , SCIP_Real * consdualvalues , SCIP_Real * varlbdualvalues , SCIP_Real * varubdualvalues ) +# Skipping MacroDefinition: SCIP_DECL_NLPISOLVE ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETSOLSTAT ( x ) SCIP_NLPSOLSTAT x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETTERMSTAT ( x ) SCIP_NLPTERMSTAT x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETSOLUTION ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_Real * * primalvalues , SCIP_Real * * consdualvalues , SCIP_Real * * varlbdualvalues , SCIP_Real * * varubdualvalues , SCIP_Real * objval ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETSTATISTICS ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_NLPSTATISTICS * statistics ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETWARMSTARTSIZE ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , size_t * size ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETWARMSTARTMEMO ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , void * buffer ) +# Skipping MacroDefinition: SCIP_DECL_NLPISETWARMSTARTMEMO ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , void * buffer ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETINTPAR ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_NLPPARAM type , int * ival ) +# Skipping MacroDefinition: SCIP_DECL_NLPISETINTPAR ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_NLPPARAM type , int ival ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETREALPAR ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_NLPPARAM type , SCIP_Real * dval ) +# Skipping MacroDefinition: SCIP_DECL_NLPISETREALPAR ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_NLPPARAM type , SCIP_Real dval ) +# Skipping MacroDefinition: SCIP_DECL_NLPIGETSTRINGPAR ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_NLPPARAM type , const char * * sval ) +# Skipping MacroDefinition: SCIP_DECL_NLPISETSTRINGPAR ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_NLPIPROBLEM * problem , SCIP_NLPPARAM type , const char * sval ) +# Skipping MacroDefinition: SCIP_DECL_NLPISETMESSAGEHDLR ( x ) SCIP_RETCODE x ( SCIP_NLPI * nlpi , SCIP_MESSAGEHDLR * messagehdlr ) + +const SCIP_Nlpi = Cvoid +const SCIP_NLPI = SCIP_Nlpi +const SCIP_NlpiData = Cvoid +const SCIP_NLPIDATA = SCIP_NlpiData +const SCIP_NlpiProblem = Cvoid +const SCIP_NLPIPROBLEM = SCIP_NlpiProblem +const SCIP_NlpStatistics = Cvoid +const SCIP_NLPSTATISTICS = SCIP_NlpStatistics + +@cenum(SCIP_NlpParam, + SCIP_NLPPAR_FROMSCRATCH = 0, + SCIP_NLPPAR_VERBLEVEL = 1, + SCIP_NLPPAR_FEASTOL = 2, + SCIP_NLPPAR_RELOBJTOL = 3, + SCIP_NLPPAR_LOBJLIM = 4, + SCIP_NLPPAR_INFINITY = 5, + SCIP_NLPPAR_ITLIM = 6, + SCIP_NLPPAR_TILIM = 7, + SCIP_NLPPAR_OPTFILE = 8, + SCIP_NLPPAR_FASTFAIL = 9, +) + +const SCIP_NLPPARAM = SCIP_NlpParam + +@cenum(SCIP_NlpSolStat, + SCIP_NLPSOLSTAT_GLOBOPT = 0, + SCIP_NLPSOLSTAT_LOCOPT = 1, + SCIP_NLPSOLSTAT_FEASIBLE = 2, + SCIP_NLPSOLSTAT_LOCINFEASIBLE = 3, + SCIP_NLPSOLSTAT_GLOBINFEASIBLE = 4, + SCIP_NLPSOLSTAT_UNBOUNDED = 5, + SCIP_NLPSOLSTAT_UNKNOWN = 6, +) + +const SCIP_NLPSOLSTAT = SCIP_NlpSolStat + +@cenum(SCIP_NlpTermStat, + SCIP_NLPTERMSTAT_OKAY = 0, + SCIP_NLPTERMSTAT_TILIM = 1, + SCIP_NLPTERMSTAT_ITLIM = 2, + SCIP_NLPTERMSTAT_LOBJLIM = 3, + SCIP_NLPTERMSTAT_NUMERR = 5, + SCIP_NLPTERMSTAT_EVALERR = 6, + SCIP_NLPTERMSTAT_MEMERR = 7, + SCIP_NLPTERMSTAT_LICERR = 8, + SCIP_NLPTERMSTAT_OTHER = 9, +) + +const SCIP_NLPTERMSTAT = SCIP_NlpTermStat From 187ea2bfa7890628e06a06b0b97953335df82906 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 23:14:16 +0100 Subject: [PATCH 20/82] include lpi headers in generate_wrapper.jl --- gen/generate_wrapper.jl | 7 ++--- src/wrapper/commons.jl | 65 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+), 4 deletions(-) diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index 92270f7b..d1c5a7bb 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -7,13 +7,12 @@ scip_headers = vcat( # filter(h -> startswith(h, "pub_"), all_headers), filter(h -> startswith(h, "scip_"), all_headers), ) -nlpi_headers = [ - "type_expr.h", - "type_nlpi.h", -] +lpi_headers = ["type_lpi.h"] +nlpi_headers = ["type_expr.h", "type_nlpi.h"] headers = vcat( [joinpath(HEADER_BASE, "scip", h) for h in scip_headers], + [joinpath(HEADER_BASE, "lpi", h) for h in lpi_headers], [joinpath(HEADER_BASE, "nlpi", h) for h in nlpi_headers], ) diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index 9378df55..67e197fc 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -1174,6 +1174,71 @@ 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_ObjSen{Int32}, + SCIP_OBJSEN_MAXIMIZE = -1, + SCIP_OBJSEN_MINIMIZE = 1, +) + +const SCIP_OBJSEN = SCIP_ObjSen + +@cenum(SCIP_LPParam, + SCIP_LPPAR_FROMSCRATCH = 0, + SCIP_LPPAR_FASTMIP = 1, + SCIP_LPPAR_SCALING = 2, + SCIP_LPPAR_PRESOLVING = 3, + SCIP_LPPAR_PRICING = 4, + SCIP_LPPAR_LPINFO = 5, + SCIP_LPPAR_FEASTOL = 6, + SCIP_LPPAR_DUALFEASTOL = 7, + SCIP_LPPAR_BARRIERCONVTOL = 8, + SCIP_LPPAR_OBJLIM = 9, + SCIP_LPPAR_LPITLIM = 10, + SCIP_LPPAR_LPTILIM = 11, + SCIP_LPPAR_MARKOWITZ = 12, + SCIP_LPPAR_ROWREPSWITCH = 13, + SCIP_LPPAR_THREADS = 14, + SCIP_LPPAR_CONDITIONLIMIT = 15, + SCIP_LPPAR_TIMING = 16, + SCIP_LPPAR_RANDOMSEED = 17, + SCIP_LPPAR_POLISHING = 18, + SCIP_LPPAR_REFACTOR = 19, +) + +const SCIP_LPPARAM = SCIP_LPParam + +@cenum(SCIP_Pricing, + SCIP_PRICING_LPIDEFAULT = 0, + SCIP_PRICING_AUTO = 1, + SCIP_PRICING_FULL = 2, + SCIP_PRICING_PARTIAL = 3, + SCIP_PRICING_STEEP = 4, + SCIP_PRICING_STEEPQSTART = 5, + SCIP_PRICING_DEVEX = 6, +) + +const SCIP_PRICING = SCIP_Pricing + +@cenum(SCIP_BaseStat, + SCIP_BASESTAT_LOWER = 0, + SCIP_BASESTAT_BASIC = 1, + SCIP_BASESTAT_UPPER = 2, + SCIP_BASESTAT_ZERO = 3, +) + +const SCIP_BASESTAT = SCIP_BaseStat + +@cenum(SCIP_LPSolQuality, + SCIP_LPSOLQUALITY_ESTIMCONDITION = 0, + SCIP_LPSOLQUALITY_EXACTCONDITION = 1, +) + +const SCIP_LPSOLQUALITY = SCIP_LPSolQuality +const SCIP_LPi = Cvoid +const SCIP_LPI = SCIP_LPi +const SCIP_LPiState = Cvoid +const SCIP_LPISTATE = SCIP_LPiState +const SCIP_LPiNorms = Cvoid +const SCIP_LPINORMS = SCIP_LPiNorms const SCIP_EXPR_DEGREEINFINITY = 65535 # Skipping MacroDefinition: SCIP_DECL_EXPREVAL ( x ) SCIP_RETCODE x ( SCIP_EXPROPDATA opdata , int nargs , SCIP_Real * argvals , SCIP_Real * varvals , SCIP_Real * paramvals , SCIP_Real * result ) From fe558bd88c68d89d58a658ef6070121f72bc8e15 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 15 Dec 2018 23:17:19 +0100 Subject: [PATCH 21/82] manually define BMS_{BLK,BUF}MEM --- src/wrapper/manual_commons.jl | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/wrapper/manual_commons.jl b/src/wrapper/manual_commons.jl index cdf84cdd..fdc84b1c 100644 --- a/src/wrapper/manual_commons.jl +++ b/src/wrapper/manual_commons.jl @@ -38,3 +38,6 @@ const SCIP_EVENTTYPE_SYNC = UInt64(0x100000000) const PRIx64 = "llx" const FILE = Cvoid + +const BMS_BLKMEM = Cvoid +const BMS_BUFMEM = Cvoid From 8c60dff1ec969016898fc992982246ef4972a229 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 16 Dec 2018 18:33:23 +0100 Subject: [PATCH 22/82] check version during module init --- src/SCIP.jl | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/SCIP.jl b/src/SCIP.jl index ee0daeb0..7e6d6181 100644 --- a/src/SCIP.jl +++ b/src/SCIP.jl @@ -1,5 +1,23 @@ module SCIP +import Libdl +const depsjl_path = joinpath(@__DIR__, "..", "deps", "deps.jl") +if !isfile(depsjl_path) + error("SCIP was not built properly, please run Pkg.build(\"SCIP\")") +end +include(depsjl_path) + +function __init__() + major = SCIPmajorVersion() + minor = SCIPminorVersion() + patch = SCIPtechVersion() + current = VersionNumber("$major.$minor.$patch") + required = VersionNumber("6.0.0") + if current < required + error("SCIP is installed at version $current, need $required or newer.") + end +end + # wrapper of SCIP library include("wrapper.jl") From e9282e044b40b0bee9aca4059f20e9765cf25a24 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 16 Dec 2018 18:46:07 +0100 Subject: [PATCH 23/82] start on first test --- test/direct_library_calls.jl | 12 ++++++++++++ test/runtests.jl | 3 +++ 2 files changed, 15 insertions(+) create mode 100644 test/direct_library_calls.jl diff --git a/test/direct_library_calls.jl b/test/direct_library_calls.jl new file mode 100644 index 00000000..b57d9074 --- /dev/null +++ b/test/direct_library_calls.jl @@ -0,0 +1,12 @@ +# Test raw wrapper with direct library calls + +@testset "create small problem and solve" begin + scip__ = Ptr{SCIP.SCIP_}[C_NULL] # SCIP** + rc = SCIP.SCIPcreate(scip__) + @test rc == SCIP.SCIP_OKAY + + scip_ = scip__[1] # SCIP* + @test rc != C_NULL + + # TODO... +end diff --git a/test/runtests.jl b/test/runtests.jl index cc57e86a..d0dddfe9 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1 +1,4 @@ using Test +using SCIP + +include("direct_library_calls.jl") From b9d1f7c46d81078e864bbc5421ec80286e0082f9 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 16 Dec 2018 21:55:32 +0100 Subject: [PATCH 24/82] generate wrapper for scipdefplugins.h --- gen/generate_wrapper.jl | 1 + src/wrapper.jl | 3 +++ src/wrapper/scipdefplugins.jl | 7 +++++++ 3 files changed, 11 insertions(+) create mode 100644 src/wrapper/scipdefplugins.jl diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index d1c5a7bb..b993496e 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -6,6 +6,7 @@ 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" ) lpi_headers = ["type_lpi.h"] nlpi_headers = ["type_expr.h", "type_nlpi.h"] diff --git a/src/wrapper.jl b/src/wrapper.jl index ae8cf839..b0e5a9a4 100644 --- a/src/wrapper.jl +++ b/src/wrapper.jl @@ -53,3 +53,6 @@ include(wrap("scip_timing")) include(wrap("scip_tree")) include(wrap("scip_validation")) include(wrap("scip_var")) + +# default SCIP plugins +include(wrap("scipdefplugins")) diff --git a/src/wrapper/scipdefplugins.jl b/src/wrapper/scipdefplugins.jl new file mode 100644 index 00000000..de1cc4b2 --- /dev/null +++ b/src/wrapper/scipdefplugins.jl @@ -0,0 +1,7 @@ +# Julia wrapper for header: /usr/include/scip/scipdefplugins.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPincludeDefaultPlugins(scip) + ccall((:SCIPincludeDefaultPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_},), scip) +end From 93218b4cbcbc03cdd2d5aaf170d4530f9a524e0f Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 16 Dec 2018 21:55:51 +0100 Subject: [PATCH 25/82] wrap included tests in named testset --- test/runtests.jl | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/runtests.jl b/test/runtests.jl index d0dddfe9..42943928 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,4 +1,6 @@ using Test using SCIP -include("direct_library_calls.jl") +@testset "direct library calls" begin + include("direct_library_calls.jl") +end From dd9bea0768319414d9545e9a75699e759ded24a0 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 16 Dec 2018 23:05:12 +0100 Subject: [PATCH 26/82] extend first test --- test/direct_library_calls.jl | 37 ++++++++++++++++++++++++++++++++---- 1 file changed, 33 insertions(+), 4 deletions(-) diff --git a/test/direct_library_calls.jl b/test/direct_library_calls.jl index b57d9074..8feff385 100644 --- a/test/direct_library_calls.jl +++ b/test/direct_library_calls.jl @@ -1,12 +1,41 @@ # Test raw wrapper with direct library calls @testset "create small problem and solve" begin - scip__ = Ptr{SCIP.SCIP_}[C_NULL] # SCIP** + scip__ = Ref{Ptr{SCIP.SCIP_}}() # SCIP** rc = SCIP.SCIPcreate(scip__) @test rc == SCIP.SCIP_OKAY - scip_ = scip__[1] # SCIP* - @test rc != C_NULL + scip_ = scip__[] # dereference to SCIP* + @test scip_ != C_NULL - # TODO... + rc = SCIP.SCIPincludeDefaultPlugins(scip_) + @test rc == SCIP.SCIP_OKAY + + # disable output + rc = SCIP.SCIPsetIntParam(scip_, "display/verblevel", 0) + @test rc == SCIP.SCIP_OKAY + + rc = SCIP.SCIPcreateProbBasic(scip_, "") + @test rc == SCIP.SCIP_OKAY + + # add variable: x >= 3, objcoef: 1 + var__ = Ref{Ptr{SCIP.SCIP_VAR}}() + rc = SCIP.SCIPcreateVarBasic(scip_, var__, "x", + 3.0, SCIP.SCIPinfinity(scip_), + 1.0, SCIP.SCIP_VARTYPE_CONTINUOUS) + @test rc == SCIP.SCIP_OKAY + var_ = var__[] + @test var_ != C_NULL + + rc = SCIP.SCIPsolve(scip_) + @test rc == SCIP.SCIP_OKAY + + # check solution value + sol_ = SCIP.SCIPgetBestSol(scip_) + @test sol_ != C_NULL + # val = SCIP.SCIPgetSolVal(scip_, sol_, var_) + # @test val ≈ 3.0 + + rc = SCIP.SCIPfree(scip__) + @test rc == SCIP.SCIP_OKAY end From c1c5f8dd562dfdddb01370c9dcccfe8847975500 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Mon, 17 Dec 2018 14:57:35 +0100 Subject: [PATCH 27/82] build.jl: check environment variable first - otherwise, if system-wide installation exists, can not point it to another installation which is useful for testing (debug mode build) --- deps/build.jl | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/deps/build.jl b/deps/build.jl index 3e52e16f..0c5bff06 100644 --- a/deps/build.jl +++ b/deps/build.jl @@ -13,14 +13,18 @@ function write_depsfile(path) end libname = "libscip.so" -paths_to_try = [libname] +paths_to_try = [] +# prefer environment variable if haskey(ENV, "SCIPOPTDIR") if Compat.Sys.isunix() push!(paths_to_try, joinpath(ENV["SCIPOPTDIR"], "lib", libname)) end end +# but also try library path +push!(paths_to_try, libname) + found = false for l in paths_to_try d = Libdl.dlopen_e(l) From 94749bc9e45a13fc03a9035fff8aa6f1cc8b4302 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Mon, 17 Dec 2018 15:08:16 +0100 Subject: [PATCH 28/82] extend first test (actually add variable) --- test/direct_library_calls.jl | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/test/direct_library_calls.jl b/test/direct_library_calls.jl index 8feff385..632706bb 100644 --- a/test/direct_library_calls.jl +++ b/test/direct_library_calls.jl @@ -26,6 +26,8 @@ @test rc == SCIP.SCIP_OKAY var_ = var__[] @test var_ != C_NULL + rc = SCIP.SCIPaddVar(scip_, var_) + @test rc == SCIP.SCIP_OKAY rc = SCIP.SCIPsolve(scip_) @test rc == SCIP.SCIP_OKAY @@ -33,9 +35,12 @@ # check solution value sol_ = SCIP.SCIPgetBestSol(scip_) @test sol_ != C_NULL - # val = SCIP.SCIPgetSolVal(scip_, sol_, var_) - # @test val ≈ 3.0 + val = SCIP.SCIPgetSolVal(scip_, sol_, var_) + @test val ≈ 3.0 + # release variables and solver + rc = SCIP.SCIPreleaseVar(scip_, var__) + @test rc == SCIP.SCIP_OKAY rc = SCIP.SCIPfree(scip__) @test rc == SCIP.SCIP_OKAY end From e7401cf874ea600ea244a26d2feb2c0db9baafd9 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Mon, 17 Dec 2018 15:15:41 +0100 Subject: [PATCH 29/82] 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 From b53ca2aec69d54ffd0452ab0f2dfe8124c649a89 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Tue, 18 Dec 2018 14:36:49 +0100 Subject: [PATCH 30/82] test: add linear constraint --- test/direct_library_calls.jl | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/test/direct_library_calls.jl b/test/direct_library_calls.jl index 632706bb..39112bf8 100644 --- a/test/direct_library_calls.jl +++ b/test/direct_library_calls.jl @@ -15,13 +15,14 @@ rc = SCIP.SCIPsetIntParam(scip_, "display/verblevel", 0) @test rc == SCIP.SCIP_OKAY + # create problem rc = SCIP.SCIPcreateProbBasic(scip_, "") @test rc == SCIP.SCIP_OKAY - # add variable: x >= 3, objcoef: 1 + # add variable: x >= 0, objcoef: 1 var__ = Ref{Ptr{SCIP.SCIP_VAR}}() rc = SCIP.SCIPcreateVarBasic(scip_, var__, "x", - 3.0, SCIP.SCIPinfinity(scip_), + 0.0, SCIP.SCIPinfinity(scip_), 1.0, SCIP.SCIP_VARTYPE_CONTINUOUS) @test rc == SCIP.SCIP_OKAY var_ = var__[] @@ -29,6 +30,19 @@ rc = SCIP.SCIPaddVar(scip_, var_) @test rc == SCIP.SCIP_OKAY + # add constraint: 2x >= 3 ( really: 3 <= 2 * x <= inf ) + cons__ = Ref{Ptr{SCIP.SCIP_VAR}}() + rc = SCIP.SCIPcreateConsBasicLinear(scip_, cons__, "c", 0, C_NULL, C_NULL, + 3.0, SCIP.SCIPinfinity(scip_)) + @test rc == SCIP.SCIP_OKAY + cons_ = cons__[] + @test cons_ != C_NULL + rc = SCIP.SCIPaddCoefLinear(scip_, cons_, var_, 2.0) + @test rc == SCIP.SCIP_OKAY + rc = SCIP.SCIPaddCons(scip_, cons_) + @test rc == SCIP.SCIP_OKAY + + # solve problem rc = SCIP.SCIPsolve(scip_) @test rc == SCIP.SCIP_OKAY @@ -36,9 +50,11 @@ sol_ = SCIP.SCIPgetBestSol(scip_) @test sol_ != C_NULL val = SCIP.SCIPgetSolVal(scip_, sol_, var_) - @test val ≈ 3.0 + @test val ≈ 3.0 / 2.0 # release variables and solver + rc = SCIP.SCIPreleaseCons(scip_, cons__) + @test rc == SCIP.SCIP_OKAY rc = SCIP.SCIPreleaseVar(scip_, var__) @test rc == SCIP.SCIP_OKAY rc = SCIP.SCIPfree(scip__) From 48103612ceeeb6b0875867ef879bbcf7c2dd623e Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Tue, 18 Dec 2018 21:33:06 +0100 Subject: [PATCH 31/82] fix type in test --- test/direct_library_calls.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/direct_library_calls.jl b/test/direct_library_calls.jl index 39112bf8..37bc447e 100644 --- a/test/direct_library_calls.jl +++ b/test/direct_library_calls.jl @@ -31,7 +31,7 @@ @test rc == SCIP.SCIP_OKAY # add constraint: 2x >= 3 ( really: 3 <= 2 * x <= inf ) - cons__ = Ref{Ptr{SCIP.SCIP_VAR}}() + cons__ = Ref{Ptr{SCIP.SCIP_CONS}}() rc = SCIP.SCIPcreateConsBasicLinear(scip_, cons__, "c", 0, C_NULL, C_NULL, 3.0, SCIP.SCIPinfinity(scip_)) @test rc == SCIP.SCIP_OKAY From 543a572dbfab5856c789ead16fdf0f9030219b13 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Tue, 18 Dec 2018 19:26:03 +0100 Subject: [PATCH 32/82] add MOI to REQUIRE --- REQUIRE | 1 + 1 file changed, 1 insertion(+) diff --git a/REQUIRE b/REQUIRE index 1ca718e6..357da5a0 100644 --- a/REQUIRE +++ b/REQUIRE @@ -1,2 +1,3 @@ julia 1.0 Compat +MathOptInterface 0.8 From 81ce845802f4d0ad1cb95d06482f272771525883 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Wed, 19 Dec 2018 21:53:53 +0100 Subject: [PATCH 33/82] prepare MOI_wrapper.jl --- src/MOI_wrapper.jl | 2 ++ src/SCIP.jl | 3 +++ 2 files changed, 5 insertions(+) create mode 100644 src/MOI_wrapper.jl diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl new file mode 100644 index 00000000..6cdf7654 --- /dev/null +++ b/src/MOI_wrapper.jl @@ -0,0 +1,2 @@ +using MathOptInterface +const MOI = MathOptInterface diff --git a/src/SCIP.jl b/src/SCIP.jl index 7e6d6181..5b2ffbad 100644 --- a/src/SCIP.jl +++ b/src/SCIP.jl @@ -21,4 +21,7 @@ end # wrapper of SCIP library include("wrapper.jl") +# implementation of MOI +include("MOI_wrapper.jl") + end From f35860ab3c23630b78e1a97141c79bf72c8dbcd3 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Thu, 20 Dec 2018 14:01:46 +0100 Subject: [PATCH 34/82] add ManagedSCIP (for memory) and include in Optimizer --- src/MOI_wrapper.jl | 4 ++++ src/SCIP.jl | 3 +++ src/managed_scip.jl | 32 ++++++++++++++++++++++++++++++++ test/managed_scip.jl | 19 +++++++++++++++++++ test/runtests.jl | 4 ++++ 5 files changed, 62 insertions(+) create mode 100644 src/managed_scip.jl create mode 100644 test/managed_scip.jl diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 6cdf7654..4c3ebecf 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -1,2 +1,6 @@ using MathOptInterface const MOI = MathOptInterface + +mutable struct Optimizer <: MOI.AbstractOptimizer + mscip::ManagedSCIP +end diff --git a/src/SCIP.jl b/src/SCIP.jl index 5b2ffbad..a34a953c 100644 --- a/src/SCIP.jl +++ b/src/SCIP.jl @@ -21,6 +21,9 @@ end # wrapper of SCIP library include("wrapper.jl") +# memory management +include("managed_scip.jl") + # implementation of MOI include("MOI_wrapper.jl") diff --git a/src/managed_scip.jl b/src/managed_scip.jl new file mode 100644 index 00000000..66e278b6 --- /dev/null +++ b/src/managed_scip.jl @@ -0,0 +1,32 @@ +# holds pointers to SCIP data and takes care of memory mgmt +mutable struct ManagedSCIP + scip::Ref{Ptr{SCIP_}} + vars::Vector{Ref{Ptr{SCIP_VAR}}} + conss::Vector{Ref{Ptr{SCIP_CONS}}} + + function ManagedSCIP() + scip = Ref{Ptr{SCIP_}}() + rc = SCIPcreate(scip) + @assert rc == SCIP_OKAY + @assert scip[] != C_NULL + rc = SCIPincludeDefaultPlugins(scip[]) + @assert rc == SCIP_OKAY + rc = SCIP.SCIPcreateProbBasic(scip[], "") + @assert rc == SCIP_OKAY + + mscip = new(scip, [], []) + finalizer(free_scip, mscip) + end +end + +"Release references and free memory" +function free_scip(mscip::ManagedSCIP) + # avoid double-free + if mscip.scip[] != C_NULL + # TODO: release all constraints + # TODO: release all variables + rc = SCIP.SCIPfree(mscip.scip) + @assert rc == SCIP_OKAY + end + @assert mscip.scip[] == C_NULL +end diff --git a/test/managed_scip.jl b/test/managed_scip.jl new file mode 100644 index 00000000..14d048bc --- /dev/null +++ b/test/managed_scip.jl @@ -0,0 +1,19 @@ +# Test memory management + +@testset "create and manual free" begin + mscip = SCIP.ManagedSCIP() + @test mscip.scip[] != C_NULL + SCIP.free_scip(mscip) +end + +@testset "create and implicit free" begin + ptr = Ref{Ptr{SCIP.SCIP_}}(C_NULL) + for i = 1:1 + mscip = SCIP.ManagedSCIP() + ptr = mscip.scip + @test ptr[] != C_NULL + end + GC.gc() + GC.gc() # TODO: why need a second call? + @test ptr[] == C_NULL +end diff --git a/test/runtests.jl b/test/runtests.jl index 42943928..d26b447d 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -4,3 +4,7 @@ using SCIP @testset "direct library calls" begin include("direct_library_calls.jl") end + +@testset "managed memory" begin + include("managed_scip.jl") +end From 49bbe949c1c16752b9d1f5ad0872e71faee57e4c Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Thu, 20 Dec 2018 14:29:00 +0100 Subject: [PATCH 35/82] manage vars, conss for ManagedSCIP --- src/managed_scip.jl | 43 ++++++++++++++++++++++++++++++++++++++++--- test/managed_scip.jl | 26 ++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 3 deletions(-) diff --git a/src/managed_scip.jl b/src/managed_scip.jl index 66e278b6..9b3ec577 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -23,10 +23,47 @@ end function free_scip(mscip::ManagedSCIP) # avoid double-free if mscip.scip[] != C_NULL - # TODO: release all constraints - # TODO: release all variables - rc = SCIP.SCIPfree(mscip.scip) + for cons in mscip.conss + rc = SCIPreleaseCons(mscip.scip[], cons) + @assert rc == SCIP_OKAY + end + for var in mscip.vars + rc = SCIPreleaseVar(mscip.scip[], var) + @assert rc == SCIP_OKAY + end + rc = SCIPfree(mscip.scip) @assert rc == SCIP_OKAY end @assert mscip.scip[] == C_NULL end + +"Add variable to problem (continuous, no bounds)" +function add_variable(mscip::ManagedSCIP) + var = Ref{Ptr{SCIP_VAR}}() + rc = SCIPcreateVarBasic( + mscip.scip[], var, "", -SCIPinfinity(mscip.scip[]), + SCIPinfinity(mscip.scip[]), 0.0, SCIP_VARTYPE_CONTINUOUS) + @assert rc == SCIP_OKAY + rc = SCIPaddVar(mscip.scip[], var[]) + @assert rc == SCIP_OKAY + + push!(mscip.vars, var) + # can't delete variable, so we use the array position as index + return length(mscip.vars) +end + +"Add (ranged) linear constraint to problem" +function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) + @assert length(varidx) == length(coeffs) + vars = [mscip.vars[i][] for i in varidx] + cons = Ref{Ptr{SCIP_CONS}}() + rc = SCIPcreateConsBasicLinear( + mscip.scip[], cons, "", length(vars), vars, coeffs, lhs, rhs) + @assert rc == SCIP_OKAY + rc = SCIPaddCons(mscip.scip[], cons[]) + @assert rc == SCIP_OKAY + + push!(mscip.conss, cons) + # can't delete constraint, so we use the array position as index + return length(mscip.conss) +end diff --git a/test/managed_scip.jl b/test/managed_scip.jl index 14d048bc..f5c668b2 100644 --- a/test/managed_scip.jl +++ b/test/managed_scip.jl @@ -4,6 +4,14 @@ mscip = SCIP.ManagedSCIP() @test mscip.scip[] != C_NULL SCIP.free_scip(mscip) + @test mscip.scip[] == C_NULL +end + +@testset "create and semi-manual free" begin + mscip = SCIP.ManagedSCIP() + @test mscip.scip[] != C_NULL + finalize(mscip) + @test mscip.scip[] == C_NULL end @testset "create and implicit free" begin @@ -17,3 +25,21 @@ end GC.gc() # TODO: why need a second call? @test ptr[] == C_NULL end + +@testset "create with vars and cons, (no solve), and free" begin + mscip = SCIP.ManagedSCIP() + @test mscip.scip[] != C_NULL + + x = SCIP.add_variable(mscip) + y = SCIP.add_variable(mscip) + c = SCIP.add_linear_constraint(mscip, [x, y], [2.0, 3.0], 1.0, 9.0) + + finalize(mscip) + for var in mscip.vars + @test var[] == C_NULL + end + for cons in mscip.conss + @test cons[] == C_NULL + end + @test mscip.scip[] == C_NULL +end From 42bed2d0d8e79947af0ed0a40fd77b807a0cd665 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Thu, 20 Dec 2018 15:02:24 +0100 Subject: [PATCH 36/82] add simple @SC macro for SCIP_CALL --- src/managed_scip.jl | 30 ++++++++++-------------------- src/wrapper.jl | 5 +++++ test/direct_library_calls.jl | 7 +++++++ 3 files changed, 22 insertions(+), 20 deletions(-) diff --git a/src/managed_scip.jl b/src/managed_scip.jl index 9b3ec577..21b7fda8 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -6,13 +6,10 @@ mutable struct ManagedSCIP function ManagedSCIP() scip = Ref{Ptr{SCIP_}}() - rc = SCIPcreate(scip) - @assert rc == SCIP_OKAY + @SC SCIPcreate(scip) @assert scip[] != C_NULL - rc = SCIPincludeDefaultPlugins(scip[]) - @assert rc == SCIP_OKAY - rc = SCIP.SCIPcreateProbBasic(scip[], "") - @assert rc == SCIP_OKAY + @SC SCIPincludeDefaultPlugins(scip[]) + @SC SCIP.SCIPcreateProbBasic(scip[], "") mscip = new(scip, [], []) finalizer(free_scip, mscip) @@ -24,15 +21,12 @@ function free_scip(mscip::ManagedSCIP) # avoid double-free if mscip.scip[] != C_NULL for cons in mscip.conss - rc = SCIPreleaseCons(mscip.scip[], cons) - @assert rc == SCIP_OKAY + @SC SCIPreleaseCons(mscip.scip[], cons) end for var in mscip.vars - rc = SCIPreleaseVar(mscip.scip[], var) - @assert rc == SCIP_OKAY + @SC SCIPreleaseVar(mscip.scip[], var) end - rc = SCIPfree(mscip.scip) - @assert rc == SCIP_OKAY + @SC SCIPfree(mscip.scip) end @assert mscip.scip[] == C_NULL end @@ -40,12 +34,10 @@ end "Add variable to problem (continuous, no bounds)" function add_variable(mscip::ManagedSCIP) var = Ref{Ptr{SCIP_VAR}}() - rc = SCIPcreateVarBasic( + @SC rc = SCIPcreateVarBasic( mscip.scip[], var, "", -SCIPinfinity(mscip.scip[]), SCIPinfinity(mscip.scip[]), 0.0, SCIP_VARTYPE_CONTINUOUS) - @assert rc == SCIP_OKAY - rc = SCIPaddVar(mscip.scip[], var[]) - @assert rc == SCIP_OKAY + @SC rc = SCIPaddVar(mscip.scip[], var[]) push!(mscip.vars, var) # can't delete variable, so we use the array position as index @@ -57,11 +49,9 @@ function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) @assert length(varidx) == length(coeffs) vars = [mscip.vars[i][] for i in varidx] cons = Ref{Ptr{SCIP_CONS}}() - rc = SCIPcreateConsBasicLinear( + @SC rc = SCIPcreateConsBasicLinear( mscip.scip[], cons, "", length(vars), vars, coeffs, lhs, rhs) - @assert rc == SCIP_OKAY - rc = SCIPaddCons(mscip.scip[], cons[]) - @assert rc == SCIP_OKAY + @SC rc = SCIPaddCons(mscip.scip[], cons[]) push!(mscip.conss, cons) # can't delete constraint, so we use the array position as index diff --git a/src/wrapper.jl b/src/wrapper.jl index 9c581aa6..af76f54f 100644 --- a/src/wrapper.jl +++ b/src/wrapper.jl @@ -90,3 +90,8 @@ include(wrap("cons_superindicator")) include(wrap("cons_symresack")) include(wrap("cons_varbound")) include(wrap("cons_xor")) + +# SCIP_CALL: macro to check return codes, inspired by @assert +macro SC(ex) + return :(@assert $(esc(ex)) == SCIP_OKAY) +end diff --git a/test/direct_library_calls.jl b/test/direct_library_calls.jl index 37bc447e..fe093c2b 100644 --- a/test/direct_library_calls.jl +++ b/test/direct_library_calls.jl @@ -60,3 +60,10 @@ rc = SCIP.SCIPfree(scip__) @test rc == SCIP.SCIP_OKAY end + +@testset "SCIP_CALL macro (@SC)" begin + # should do nothing + @SCIP.SC SCIP.SCIP_OKAY + + @test_throws AssertionError @SCIP.SC SCIP.SCIP_ERROR +end From f50bef4e3aa4628f40c8211436550bc07708ecab Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Thu, 20 Dec 2018 20:55:37 +0100 Subject: [PATCH 37/82] add Travis CI config --- .travis.yml | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 .travis.yml diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 00000000..05e54946 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,21 @@ +## Documentation: http://docs.travis-ci.com/user/languages/julia/ +language: julia +os: + - linux +julia: + - 1.0 + - nightly +notifications: + email: false +git: + depth: 99999999 +matrix: + allow_failures: + - julia: nightly +script: + - julia -e 'Pkg.clone(pwd()); Pkg.build("SCIP"); Pkg.test("SCIP"; coverage=true)' +after_success: + # push coverage results to Coveralls + - julia -e 'cd(Pkg.dir("SCIP")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())' + # push coverage results to Codecov + - julia -e 'cd(Pkg.dir("SCIP")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())' From d3316aa7776e3d402dfead992dc309ae80517081 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Thu, 20 Dec 2018 20:59:15 +0100 Subject: [PATCH 38/82] travis: install scip .deb package - use info from PySCIPOpt - also switch to Ubuntu Xenial --- .travis.yml | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 05e54946..bb201e64 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,8 @@ ## Documentation: http://docs.travis-ci.com/user/languages/julia/ language: julia -os: - - linux +os: linux +dist: xenial +sudo: true julia: - 1.0 - nightly @@ -12,6 +13,10 @@ git: matrix: allow_failures: - julia: nightly +before_install: + - export VERSION=6.0.0 + - wget http://scip.zib.de/download/release/SCIPOptSuite-$VERSION-Linux.deb + - sudo dpkg -i SCIPOptSuite-$VERSION-Linux.deb script: - julia -e 'Pkg.clone(pwd()); Pkg.build("SCIP"); Pkg.test("SCIP"; coverage=true)' after_success: From 5a96eaec94e8cc3cc60506b0a669ee95a52ddb72 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Thu, 20 Dec 2018 21:01:10 +0100 Subject: [PATCH 39/82] travis: add `using Pkg` --- .travis.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index bb201e64..714007ca 100644 --- a/.travis.yml +++ b/.travis.yml @@ -18,9 +18,9 @@ before_install: - wget http://scip.zib.de/download/release/SCIPOptSuite-$VERSION-Linux.deb - sudo dpkg -i SCIPOptSuite-$VERSION-Linux.deb script: - - julia -e 'Pkg.clone(pwd()); Pkg.build("SCIP"); Pkg.test("SCIP"; coverage=true)' + - julia -e 'using Pkg; Pkg.clone(pwd()); Pkg.build("SCIP"); Pkg.test("SCIP"; coverage=true)' after_success: # push coverage results to Coveralls - - julia -e 'cd(Pkg.dir("SCIP")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())' + - julia -e 'using Pkg; cd(Pkg.dir("SCIP")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())' # push coverage results to Codecov - - julia -e 'cd(Pkg.dir("SCIP")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())' + - julia -e 'using Pkg; cd(Pkg.dir("SCIP")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())' From 5d08d9a859b07c8aa3c1677bb22eb3580e820ae4 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Thu, 20 Dec 2018 21:08:27 +0100 Subject: [PATCH 40/82] travis: install some dependencies --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index 714007ca..cebcc09e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -14,6 +14,7 @@ matrix: allow_failures: - julia: nightly before_install: + - sudo apt-get install libblas-dev liblapack-dev gfortran - export VERSION=6.0.0 - wget http://scip.zib.de/download/release/SCIPOptSuite-$VERSION-Linux.deb - sudo dpkg -i SCIPOptSuite-$VERSION-Linux.deb From 2f8cd783f156548dc40702a749eee0823508f9f0 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Thu, 20 Dec 2018 21:24:46 +0100 Subject: [PATCH 41/82] add .codecov.yml --- .codecov.yml | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .codecov.yml diff --git a/.codecov.yml b/.codecov.yml new file mode 100644 index 00000000..bca08db9 --- /dev/null +++ b/.codecov.yml @@ -0,0 +1,2 @@ +ignore: + - "src/wrapper/*" From de1a030abda780bbc7bcb25c1bb3330b39cdb54b Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 00:37:12 +0100 Subject: [PATCH 42/82] implement more methods to support contlineartest (WIP) --- src/MOI_wrapper.jl | 152 ++++++++++++++++++++++++++++++++++++++++++++ src/managed_scip.jl | 11 +++- test/MOI_wrapper.jl | 29 +++++++++ test/runtests.jl | 4 ++ 4 files changed, 195 insertions(+), 1 deletion(-) create mode 100644 test/MOI_wrapper.jl diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 4c3ebecf..1d7f5468 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -1,6 +1,158 @@ using MathOptInterface const MOI = MathOptInterface +const MOIU = MOI.Utilities + +const VI = MOI.VariableIndex +const CI = MOI.ConstraintIndex + +const ConsMap = Dict{Tuple{DataType, DataType}, Vector{Int}} mutable struct Optimizer <: MOI.AbstractOptimizer mscip::ManagedSCIP + cons::ConsMap + + Optimizer() = new(ManagedSCIP(), ConsMap()) +end + + +## convenience methods (not part of MOI) + +"Returns pointer to SCIP instance" +get_scip(o::Optimizer) = get_scip(o.mscip) + +"Returns pointer to SCIP variable" +get_var(o::Optimizer, v::VI) = get_var(o.mscip, v.value) + +"Returns pointer to SCIP constraint" +get_cons(o::Optimizer, v::CI{F,S}) where {F,S} = get_cons(o.mscip, c.value) + +"Extract bounds from sets" +bounds(set::MOI.EqualTo{Float64}) = (set.value, set.value) +bounds(set::MOI.GreaterThan{Float64}) = (set.lower, nothing) +bounds(set::MOI.LessThan{Float64}) = (nothing, set.upper) +bounds(set::MOI.Interval{Float64}) = (set.lower, set.upper) + +"Register constraint in mapping" +function register!(o::Optimizer, c::CI{F,S}) where {F,S} + if haskey(o.cons, (F, S)) + push!(o.cons[F,S], c.value) + else + o.cons[F,S] = [c.value] + end + return c +end + +## general queries and support + +MOI.get(::Optimizer, ::MOI.SolverName) = "SCIP" + +# support variable bounds and linear constraints +const SF = Union{MOI.SingleVariable, + MOI.ScalarAffineFunction{Float64}} +const SS = Union{MOI.EqualTo{Float64}, + MOI.GreaterThan{Float64}, + MOI.LessThan{Float64}, + MOI.Interval{Float64}} +MOI.supports_constraint(o::Optimizer, ::Type{<:SF}, ::Type{<:SS}) = true + +MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true +MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}) = true + +MOIU.supports_allocate_load(o::Optimizer, copy_names::Bool) = !copy_names + + +## model creation, query and modification + +function MOI.is_empty(o::Optimizer) + length(o.mscip.vars) == 0 && length(o.mscip.conss) == 0 +end + +function MOI.empty!(o::Optimizer) + # free the underlying problem + finalize(o.mscip) + # create a new one + o.mscip = ManagedSCIP() + return nothing +end + +function MOI.copy_to(dest::Optimizer, src::MOI.ModelLike; kws...) + MOIU.automatic_copy_to(dest, src; kws...) +end + +MOI.add_variable(o::Optimizer) = MOI.VariableIndex(add_variable(o.mscip)) +MOI.add_variables(o::Optimizer, n) = [MOI.add_variable(o) for i=1:n] +MOI.get(o::Optimizer, ::MOI.NumberOfVariables) = length(o.mscip.vars) + +function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, + set::S) where S <: SS + var = get_var(o, func.variable) + lb, ub = bounds(set) + lb == nothing || @SC SCIPchgVarLb(get_scip(o), var, lb) + ub == nothing || @SC SCIPchgVarUb(get_scip(o), var, ub) + # use var index for cons index of this type + i = func.variable.value + return register!(o, CI{MOI.SingleVariable, S}(i)) +end + +function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64}, + set::S) where {S <: SS} + scip = get_scip(o) + + varidx = [t.variable_index.value for t in func.terms] + coefs = [t.coefficient for t in func.terms] + + lhs, rhs = bounds(set) + lhs = lhs == nothing ? -SCIPinfinity(scip) : lhs - func.constant + rhs = rhs == nothing ? SCIPinfinity(scip) : rhs - func.constant + + i = add_linear_constraint(o.mscip, varidx, coefs, lhs, rhs) + return register!(o, CI{MOI.ScalarAffineFunction{Float64}, S}(i)) +end + +function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} + haskey(o.cons, (F, S)) ? length(o.cons[F, S]) : 0 +end + +function MOI.set(o::Optimizer, + ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, + obj::MOI.ScalarAffineFunction{Float64}) + scip = get_scip(o) + + # reset objective coefficient of all variables first + for v in o.mscip.vars + @SC SCIPchgVarObj(scip, v[], 0.0) + end + + # set new objective coefficients + for t in obj.terms + @SC SCIPchgVarObj(scip, get_var(o, t.variable_index), t.coefficient) + end + + @SC SCIPaddOrigObjoffset(scip, obj.constant - SCIPgetOrigObjoffset(scip)) + + return nothing +end + +function MOI.set(o::Optimizer, ::MOI.ObjectiveSense, + sense::MOI.OptimizationSense) + if sense == MOI.MIN_SENSE + @SC SCIPsetObjsense(get_scip(o), SCIP_OBJSENSE_MINIMIZE) + elseif sense == MOI.MAX_SENSE + @SC SCIPsetObjsense(get_scip(o), SCIP_OBJSENSE_MAXIMIZE) + end + return nothing +end + +function MOI.get(o::Optimizer, ::MOI.ObjectiveSense) + SCIPgetObjsense(get_scip(o)) == SCIP_OBJSENSE_MAXIMIZE ? + MOI.MAX_SENSE : + MOI.MIN_SENSE +end + + +## optimization and results + +function MOI.optimize!(o::Optimizer) + @SC SCIPsolve(o.mscip.scip[]) + return nothing end diff --git a/src/managed_scip.jl b/src/managed_scip.jl index 21b7fda8..18b9af7d 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -31,6 +31,15 @@ function free_scip(mscip::ManagedSCIP) @assert mscip.scip[] == C_NULL end +"Returns pointer to SCIP instance" +get_scip(mscip::ManagedSCIP) = mscip.scip[] + +"Returns pointer to SCIP variable" +get_var(mscip::ManagedSCIP, i::Int) = mscip.vars[i][] + +"Returns pointer to SCIP constraint" +get_cons(mscip::ManagedSCIP, i::Int) = mscip.conss[i][] + "Add variable to problem (continuous, no bounds)" function add_variable(mscip::ManagedSCIP) var = Ref{Ptr{SCIP_VAR}}() @@ -47,7 +56,7 @@ end "Add (ranged) linear constraint to problem" function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) @assert length(varidx) == length(coeffs) - vars = [mscip.vars[i][] for i in varidx] + vars = [get_var(mscip, i) for i in varidx] cons = Ref{Ptr{SCIP_CONS}}() @SC rc = SCIPcreateConsBasicLinear( mscip.scip[], cons, "", length(vars), vars, coeffs, lhs, rhs) diff --git a/test/MOI_wrapper.jl b/test/MOI_wrapper.jl new file mode 100644 index 00000000..5cb93209 --- /dev/null +++ b/test/MOI_wrapper.jl @@ -0,0 +1,29 @@ +using MathOptInterface +const MOI = MathOptInterface +const MOIT = MOI.Test + +const optimizer = SCIP.Optimizer() +const config = MOIT.TestConfig(duals=false, infeas_certificates=false) + +@testset "MOI Continuous Linear" begin + excluded = [ + "linear1", + "linear2", + "linear3", + "linear4", + "linear5", + "linear6", + "linear7", + "linear8a", + "linear8b", + "linear8c", + "linear9", + "linear10", + "linear11", + "linear12", + "linear13", + "linear14", + "linear15", + ] + MOIT.contlineartest(optimizer, config, excluded) +end diff --git a/test/runtests.jl b/test/runtests.jl index d26b447d..04670db4 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -8,3 +8,7 @@ end @testset "managed memory" begin include("managed_scip.jl") end + +@testset "MathOptInterface tests" begin + include("MOI_wrapper.jl") +end From eab75e87617156dff3df25dd31a10580f3b3d4fe Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 12:12:23 +0100 Subject: [PATCH 43/82] generate_wrapper: include pub_*.h headers - need it now for SCIPvarGetObj from pub_var.h --- gen/generate_wrapper.jl | 2 +- src/wrapper.jl | 41 + src/wrapper/commons.jl | 2 + src/wrapper/pub_bandit.jl | 23 + src/wrapper/pub_bandit_epsgreedy.jl | 15 + src/wrapper/pub_bandit_exp3.jl | 19 + src/wrapper/pub_bandit_ucb.jl | 15 + src/wrapper/pub_benders.jl | 159 +++ src/wrapper/pub_benderscut.jl | 67 ++ src/wrapper/pub_branch.jl | 83 ++ src/wrapper/pub_compr.jl | 55 + src/wrapper/pub_conflict.jl | 43 + src/wrapper/pub_cons.jl | 503 ++++++++++ src/wrapper/pub_cutpool.jl | 39 + src/wrapper/pub_dialog.jl | 91 ++ src/wrapper/pub_disp.jl | 55 + src/wrapper/pub_event.jl | 103 ++ src/wrapper/pub_fileio.jl | 59 ++ src/wrapper/pub_heur.jl | 235 +++++ src/wrapper/pub_history.jl | 23 + src/wrapper/pub_implics.jl | 39 + src/wrapper/pub_lp.jl | 243 +++++ src/wrapper/pub_matrix.jl | 135 +++ src/wrapper/pub_message.jl | 51 + src/wrapper/pub_misc.jl | 851 ++++++++++++++++ src/wrapper/pub_misc_linear.jl | 27 + src/wrapper/pub_misc_select.jl | 939 +++++++++++++++++ src/wrapper/pub_misc_sort.jl | 1451 +++++++++++++++++++++++++++ src/wrapper/pub_nlp.jl | 99 ++ src/wrapper/pub_nodesel.jl | 39 + src/wrapper/pub_paramset.jl | 111 ++ src/wrapper/pub_presol.jl | 99 ++ src/wrapper/pub_pricer.jl | 59 ++ src/wrapper/pub_prop.jl | 155 +++ src/wrapper/pub_reader.jl | 31 + src/wrapper/pub_relax.jl | 55 + src/wrapper/pub_reopt.jl | 91 ++ src/wrapper/pub_sepa.jl | 103 ++ src/wrapper/pub_sol.jl | 75 ++ src/wrapper/pub_table.jl | 35 + src/wrapper/pub_tree.jl | 103 ++ src/wrapper/pub_var.jl | 667 ++++++++++++ 42 files changed, 7089 insertions(+), 1 deletion(-) create mode 100644 src/wrapper/pub_bandit.jl create mode 100644 src/wrapper/pub_bandit_epsgreedy.jl create mode 100644 src/wrapper/pub_bandit_exp3.jl create mode 100644 src/wrapper/pub_bandit_ucb.jl create mode 100644 src/wrapper/pub_benders.jl create mode 100644 src/wrapper/pub_benderscut.jl create mode 100644 src/wrapper/pub_branch.jl create mode 100644 src/wrapper/pub_compr.jl create mode 100644 src/wrapper/pub_conflict.jl create mode 100644 src/wrapper/pub_cons.jl create mode 100644 src/wrapper/pub_cutpool.jl create mode 100644 src/wrapper/pub_dialog.jl create mode 100644 src/wrapper/pub_disp.jl create mode 100644 src/wrapper/pub_event.jl create mode 100644 src/wrapper/pub_fileio.jl create mode 100644 src/wrapper/pub_heur.jl create mode 100644 src/wrapper/pub_history.jl create mode 100644 src/wrapper/pub_implics.jl create mode 100644 src/wrapper/pub_lp.jl create mode 100644 src/wrapper/pub_matrix.jl create mode 100644 src/wrapper/pub_message.jl create mode 100644 src/wrapper/pub_misc.jl create mode 100644 src/wrapper/pub_misc_linear.jl create mode 100644 src/wrapper/pub_misc_select.jl create mode 100644 src/wrapper/pub_misc_sort.jl create mode 100644 src/wrapper/pub_nlp.jl create mode 100644 src/wrapper/pub_nodesel.jl create mode 100644 src/wrapper/pub_paramset.jl create mode 100644 src/wrapper/pub_presol.jl create mode 100644 src/wrapper/pub_pricer.jl create mode 100644 src/wrapper/pub_prop.jl create mode 100644 src/wrapper/pub_reader.jl create mode 100644 src/wrapper/pub_relax.jl create mode 100644 src/wrapper/pub_reopt.jl create mode 100644 src/wrapper/pub_sepa.jl create mode 100644 src/wrapper/pub_sol.jl create mode 100644 src/wrapper/pub_table.jl create mode 100644 src/wrapper/pub_tree.jl create mode 100644 src/wrapper/pub_var.jl diff --git a/gen/generate_wrapper.jl b/gen/generate_wrapper.jl index 70e0fa06..668dc434 100644 --- a/gen/generate_wrapper.jl +++ b/gen/generate_wrapper.jl @@ -4,7 +4,7 @@ HEADER_BASE = "/usr/include" # using system-wide installation of SCIP all_headers = readdir(joinpath(HEADER_BASE, "scip")) scip_headers = vcat( filter(h -> startswith(h, "type_"), all_headers), - # filter(h -> startswith(h, "pub_"), all_headers), + filter(h -> startswith(h, "pub_"), all_headers), filter(h -> startswith(h, "scip_"), all_headers), "scipdefplugins.h", filter(h -> startswith(h, "cons_"), all_headers), diff --git a/src/wrapper.jl b/src/wrapper.jl index af76f54f..ddadcb6d 100644 --- a/src/wrapper.jl +++ b/src/wrapper.jl @@ -57,6 +57,47 @@ include(wrap("scip_var")) # default SCIP plugins include(wrap("scipdefplugins")) +# other public headers +include(wrap("pub_bandit_epsgreedy")) +include(wrap("pub_bandit_exp3")) +include(wrap("pub_bandit")) +include(wrap("pub_bandit_ucb")) +include(wrap("pub_benderscut")) +include(wrap("pub_benders")) +include(wrap("pub_branch")) +include(wrap("pub_compr")) +include(wrap("pub_conflict")) +include(wrap("pub_cons")) +include(wrap("pub_cutpool")) +include(wrap("pub_dialog")) +include(wrap("pub_disp")) +include(wrap("pub_event")) +include(wrap("pub_fileio")) +include(wrap("pub_heur")) +include(wrap("pub_history")) +include(wrap("pub_implics")) +include(wrap("pub_lp")) +include(wrap("pub_matrix")) +include(wrap("pub_message")) +include(wrap("pub_misc")) +include(wrap("pub_misc_linear")) +include(wrap("pub_misc_select")) +include(wrap("pub_misc_sort")) +include(wrap("pub_nlp")) +include(wrap("pub_nodesel")) +include(wrap("pub_paramset")) +include(wrap("pub_presol")) +include(wrap("pub_pricer")) +include(wrap("pub_prop")) +include(wrap("pub_reader")) +include(wrap("pub_relax")) +include(wrap("pub_reopt")) +include(wrap("pub_sepa")) +include(wrap("pub_sol")) +include(wrap("pub_table")) +include(wrap("pub_tree")) +include(wrap("pub_var")) + # all constraint types include(wrap("cons_abspower")) include(wrap("cons_and")) diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl index 589df564..0ce24089 100644 --- a/src/wrapper/commons.jl +++ b/src/wrapper/commons.jl @@ -1125,6 +1125,8 @@ const SCIP_VARDATA = SCIP_VarData const SCIP_VBCCOLOR = SCIP_VBCColor const SCIP_Visual = Cvoid const SCIP_VISUAL = SCIP_Visual +const SCIP_File = Cvoid +const SCIP_FILE = SCIP_File # Skipping MacroDefinition: SCIPallocMemory ( scip , ptr ) ( ( BMSallocMemory ( ( ptr ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) # Skipping MacroDefinition: SCIPallocMemoryArray ( scip , ptr , num ) ( ( BMSallocMemoryArray ( ( ptr ) , ( num ) ) == NULL ) ? SCIP_NOMEMORY : SCIP_OKAY ) diff --git a/src/wrapper/pub_bandit.jl b/src/wrapper/pub_bandit.jl new file mode 100644 index 00000000..35e7489b --- /dev/null +++ b/src/wrapper/pub_bandit.jl @@ -0,0 +1,23 @@ +# Julia wrapper for header: /usr/include/scip/pub_bandit.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPbanditSelect(bandit, action) + ccall((:SCIPbanditSelect, libscip), SCIP_RETCODE, (Ptr{SCIP_BANDIT}, Ptr{Cint}), bandit, action) +end + +function SCIPbanditUpdate(bandit, action, score) + ccall((:SCIPbanditUpdate, libscip), SCIP_RETCODE, (Ptr{SCIP_BANDIT}, Cint, Cdouble), bandit, action, score) +end + +function SCIPbanditvtableGetName(banditvtable) + ccall((:SCIPbanditvtableGetName, libscip), Cstring, (Ptr{SCIP_BANDITVTABLE},), banditvtable) +end + +function SCIPbanditGetRandnumgen() + ccall((:SCIPbanditGetRandnumgen, libscip), Ptr{Cint}, ()) +end + +function SCIPbanditGetNActions(bandit) + ccall((:SCIPbanditGetNActions, libscip), Cint, (Ptr{SCIP_BANDIT},), bandit) +end diff --git a/src/wrapper/pub_bandit_epsgreedy.jl b/src/wrapper/pub_bandit_epsgreedy.jl new file mode 100644 index 00000000..91701e79 --- /dev/null +++ b/src/wrapper/pub_bandit_epsgreedy.jl @@ -0,0 +1,15 @@ +# Julia wrapper for header: /usr/include/scip/pub_bandit_epsgreedy.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPcreateBanditEpsgreedy(scip, epsgreedy, priorities, eps, preferrecent, decayfactor, avglim, nactions, initseed) + ccall((:SCIPcreateBanditEpsgreedy, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, UInt32, Cdouble, Cint, Cint, UInt32), scip, epsgreedy, priorities, eps, preferrecent, decayfactor, avglim, nactions, initseed) +end + +function SCIPgetWeightsEpsgreedy(epsgreedy) + ccall((:SCIPgetWeightsEpsgreedy, libscip), Ptr{Cdouble}, (Ptr{SCIP_BANDIT},), epsgreedy) +end + +function SCIPsetEpsilonEpsgreedy(epsgreedy, eps) + ccall((:SCIPsetEpsilonEpsgreedy, libscip), Cvoid, (Ptr{SCIP_BANDIT}, Cdouble), epsgreedy, eps) +end diff --git a/src/wrapper/pub_bandit_exp3.jl b/src/wrapper/pub_bandit_exp3.jl new file mode 100644 index 00000000..c6b1c015 --- /dev/null +++ b/src/wrapper/pub_bandit_exp3.jl @@ -0,0 +1,19 @@ +# Julia wrapper for header: /usr/include/scip/pub_bandit_exp3.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPcreateBanditExp3(scip, exp3, priorities, gammaparam, beta, nactions, initseed) + ccall((:SCIPcreateBanditExp3, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, Cdouble, Cint, UInt32), scip, exp3, priorities, gammaparam, beta, nactions, initseed) +end + +function SCIPsetGammaExp3(exp3, gammaparam) + ccall((:SCIPsetGammaExp3, libscip), Cvoid, (Ptr{SCIP_BANDIT}, Cdouble), exp3, gammaparam) +end + +function SCIPsetBetaExp3(exp3, beta) + ccall((:SCIPsetBetaExp3, libscip), Cvoid, (Ptr{SCIP_BANDIT}, Cdouble), exp3, beta) +end + +function SCIPgetProbabilityExp3(exp3, action) + ccall((:SCIPgetProbabilityExp3, libscip), Cdouble, (Ptr{SCIP_BANDIT}, Cint), exp3, action) +end diff --git a/src/wrapper/pub_bandit_ucb.jl b/src/wrapper/pub_bandit_ucb.jl new file mode 100644 index 00000000..cedae78c --- /dev/null +++ b/src/wrapper/pub_bandit_ucb.jl @@ -0,0 +1,15 @@ +# Julia wrapper for header: /usr/include/scip/pub_bandit_ucb.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPcreateBanditUcb(scip, ucb, priorities, alpha, nactions, initseed) + ccall((:SCIPcreateBanditUcb, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, Cint, UInt32), scip, ucb, priorities, alpha, nactions, initseed) +end + +function SCIPgetConfidenceBoundUcb(ucb, action) + ccall((:SCIPgetConfidenceBoundUcb, libscip), Cdouble, (Ptr{SCIP_BANDIT}, Cint), ucb, action) +end + +function SCIPgetStartPermutationUcb(ucb) + ccall((:SCIPgetStartPermutationUcb, libscip), Ptr{Cint}, (Ptr{SCIP_BANDIT},), ucb) +end diff --git a/src/wrapper/pub_benders.jl b/src/wrapper/pub_benders.jl new file mode 100644 index 00000000..f981cf4e --- /dev/null +++ b/src/wrapper/pub_benders.jl @@ -0,0 +1,159 @@ +# Julia wrapper for header: /usr/include/scip/pub_benders.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPbendersComp(elem1, elem2) + ccall((:SCIPbendersComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPbendersCompName(elem1, elem2) + ccall((:SCIPbendersCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPbendersGetData(benders) + ccall((:SCIPbendersGetData, libscip), Ptr{SCIP_BENDERSDATA}, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSetData(benders, bendersdata) + ccall((:SCIPbendersSetData, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Ptr{SCIP_BENDERSDATA}), benders, bendersdata) +end + +function SCIPbendersGetName(benders) + ccall((:SCIPbendersGetName, libscip), Cstring, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetDesc(benders) + ccall((:SCIPbendersGetDesc, libscip), Cstring, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetPriority(benders) + ccall((:SCIPbendersGetPriority, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetNSubproblems(benders) + ccall((:SCIPbendersGetNSubproblems, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSubproblem(benders, probnumber) + ccall((:SCIPbendersSubproblem, libscip), Ptr{SCIP_}, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersGetNCalls(benders) + ccall((:SCIPbendersGetNCalls, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetNCutsFound(benders) + ccall((:SCIPbendersGetNCutsFound, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetSetupTime(benders) + ccall((:SCIPbendersGetSetupTime, libscip), Cdouble, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetTime(benders) + ccall((:SCIPbendersGetTime, libscip), Cdouble, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersIsInitialized(benders) + ccall((:SCIPbendersIsInitialized, libscip), UInt32, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersIsActive(benders) + ccall((:SCIPbendersIsActive, libscip), UInt32, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersOnlyCheckConvexRelax(benders) + ccall((:SCIPbendersOnlyCheckConvexRelax, libscip), UInt32, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersCutLP(benders) + ccall((:SCIPbendersCutLP, libscip), UInt32, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersCutPseudo(benders) + ccall((:SCIPbendersCutPseudo, libscip), UInt32, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersCutRelaxation(benders) + ccall((:SCIPbendersCutRelaxation, libscip), UInt32, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersShareAuxVars(benders) + ccall((:SCIPbendersShareAuxVars, libscip), UInt32, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetAuxiliaryVar(benders, probnumber) + ccall((:SCIPbendersGetAuxiliaryVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersGetAuxiliaryVars(benders) + ccall((:SCIPbendersGetAuxiliaryVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSetSubproblemObjval(benders, probnumber, objval) + ccall((:SCIPbendersSetSubproblemObjval, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cdouble), benders, probnumber, objval) +end + +function SCIPbendersGetSubproblemObjval(benders, probnumber) + ccall((:SCIPbendersGetSubproblemObjval, libscip), Cdouble, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPfindBenderscut(benders, name) + ccall((:SCIPfindBenderscut, libscip), Ptr{SCIP_BENDERSCUT}, (Ptr{SCIP_BENDERS}, Cstring), benders, name) +end + +function SCIPbendersGetBenderscuts(benders) + ccall((:SCIPbendersGetBenderscuts, libscip), Ptr{Ptr{SCIP_BENDERSCUT}}, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetNBenderscuts(benders) + ccall((:SCIPbendersGetNBenderscuts, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSetBenderscutPriority(benders, benderscut, priority) + ccall((:SCIPbendersSetBenderscutPriority, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERS}, Ptr{SCIP_BENDERSCUT}, Cint), benders, benderscut, priority) +end + +function SCIPbendersSetSubproblemIsConvex(benders, probnumber, isconvex) + ccall((:SCIPbendersSetSubproblemIsConvex, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, UInt32), benders, probnumber, isconvex) +end + +function SCIPbendersSubproblemIsConvex(benders, probnumber) + ccall((:SCIPbendersSubproblemIsConvex, libscip), UInt32, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersGetNConvexSubproblems(benders) + ccall((:SCIPbendersGetNConvexSubproblems, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSolveSubproblemLP(scip, benders, probnumber, infeasible) + ccall((:SCIPbendersSolveSubproblemLP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Cint, Ptr{UInt32}), scip, benders, probnumber, infeasible) +end + +function SCIPbendersSolveSubproblemCIP(scip, benders, probnumber, infeasible, type, solvecip) + ccall((:SCIPbendersSolveSubproblemCIP, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_BENDERS}, Cint, Ptr{UInt32}, SCIP_BENDERSENFOTYPE, UInt32), scip, benders, probnumber, infeasible, type, solvecip) +end + +function SCIPbendersGetNTransferredCuts(benders) + ccall((:SCIPbendersGetNTransferredCuts, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersUpdateSubproblemLowerbound(benders, probnumber, lowerbound) + ccall((:SCIPbendersUpdateSubproblemLowerbound, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cdouble), benders, probnumber, lowerbound) +end + +function SCIPbendersGetSubproblemLowerbound(benders, probnumber) + ccall((:SCIPbendersGetSubproblemLowerbound, libscip), Cdouble, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersSetSubproblemIsIndependent(benders, probnumber, isindep) + ccall((:SCIPbendersSetSubproblemIsIndependent, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, UInt32), benders, probnumber, isindep) +end + +function SCIPbendersSubproblemIsIndependent(benders, probnumber) + ccall((:SCIPbendersSubproblemIsIndependent, libscip), UInt32, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersSubproblemIsEnabled(benders, probnumber) + ccall((:SCIPbendersSubproblemIsEnabled, libscip), UInt32, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end diff --git a/src/wrapper/pub_benderscut.jl b/src/wrapper/pub_benderscut.jl new file mode 100644 index 00000000..98c63750 --- /dev/null +++ b/src/wrapper/pub_benderscut.jl @@ -0,0 +1,67 @@ +# Julia wrapper for header: /usr/include/scip/pub_benderscut.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPbenderscutComp(elem1, elem2) + ccall((:SCIPbenderscutComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPbenderscutCompName(elem1, elem2) + ccall((:SCIPbenderscutCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPbenderscutGetData(benderscut) + ccall((:SCIPbenderscutGetData, libscip), Ptr{SCIP_BENDERSCUTDATA}, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutSetData(benderscut, benderscutdata) + ccall((:SCIPbenderscutSetData, libscip), Cvoid, (Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_BENDERSCUTDATA}), benderscut, benderscutdata) +end + +function SCIPbenderscutGetName(benderscut) + ccall((:SCIPbenderscutGetName, libscip), Cstring, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutGetDesc(benderscut) + ccall((:SCIPbenderscutGetDesc, libscip), Cstring, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutGetPriority(benderscut) + ccall((:SCIPbenderscutGetPriority, libscip), Cint, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutGetNCalls(benderscut) + ccall((:SCIPbenderscutGetNCalls, libscip), Clonglong, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutGetNFound(benderscut) + ccall((:SCIPbenderscutGetNFound, libscip), Clonglong, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutIsInitialized(benderscut) + ccall((:SCIPbenderscutIsInitialized, libscip), UInt32, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutGetSetupTime(benderscut) + ccall((:SCIPbenderscutGetSetupTime, libscip), Cdouble, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutGetTime(benderscut) + ccall((:SCIPbenderscutGetTime, libscip), Cdouble, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutGetAddedConss(benderscut, addedconss, naddedconss) + ccall((:SCIPbenderscutGetAddedConss, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERSCUT}, Ptr{Ptr{Ptr{SCIP_CONS}}}, Ptr{Cint}), benderscut, addedconss, naddedconss) +end + +function SCIPbenderscutGetAddedCuts(benderscut, addedcuts, naddedcuts) + ccall((:SCIPbenderscutGetAddedCuts, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERSCUT}, Ptr{Ptr{Ptr{SCIP_ROW}}}, Ptr{Cint}), benderscut, addedcuts, naddedcuts) +end + +function SCIPbenderscutIsLPCut(benderscut) + ccall((:SCIPbenderscutIsLPCut, libscip), UInt32, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutSetEnabled(benderscut, enabled) + ccall((:SCIPbenderscutSetEnabled, libscip), Cvoid, (Ptr{SCIP_BENDERSCUT}, UInt32), benderscut, enabled) +end diff --git a/src/wrapper/pub_branch.jl b/src/wrapper/pub_branch.jl new file mode 100644 index 00000000..c0ed0a73 --- /dev/null +++ b/src/wrapper/pub_branch.jl @@ -0,0 +1,83 @@ +# Julia wrapper for header: /usr/include/scip/pub_branch.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPbranchruleComp(elem1, elem2) + ccall((:SCIPbranchruleComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPbranchruleCompName(elem1, elem2) + ccall((:SCIPbranchruleCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPbranchruleGetData(branchrule) + ccall((:SCIPbranchruleGetData, libscip), Ptr{SCIP_BRANCHRULEDATA}, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleSetData(branchrule, branchruledata) + ccall((:SCIPbranchruleSetData, libscip), Cvoid, (Ptr{SCIP_BRANCHRULE}, Ptr{SCIP_BRANCHRULEDATA}), branchrule, branchruledata) +end + +function SCIPbranchruleGetName(branchrule) + ccall((:SCIPbranchruleGetName, libscip), Cstring, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetDesc(branchrule) + ccall((:SCIPbranchruleGetDesc, libscip), Cstring, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetPriority(branchrule) + ccall((:SCIPbranchruleGetPriority, libscip), Cint, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetMaxdepth(branchrule) + ccall((:SCIPbranchruleGetMaxdepth, libscip), Cint, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetMaxbounddist(branchrule) + ccall((:SCIPbranchruleGetMaxbounddist, libscip), Cdouble, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetSetupTime(branchrule) + ccall((:SCIPbranchruleGetSetupTime, libscip), Cdouble, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetTime(branchrule) + ccall((:SCIPbranchruleGetTime, libscip), Cdouble, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetNLPCalls(branchrule) + ccall((:SCIPbranchruleGetNLPCalls, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetNExternCalls(branchrule) + ccall((:SCIPbranchruleGetNExternCalls, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetNPseudoCalls(branchrule) + ccall((:SCIPbranchruleGetNPseudoCalls, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetNCutoffs(branchrule) + ccall((:SCIPbranchruleGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetNCutsFound(branchrule) + ccall((:SCIPbranchruleGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetNConssFound(branchrule) + ccall((:SCIPbranchruleGetNConssFound, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetNDomredsFound(branchrule) + ccall((:SCIPbranchruleGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetNChildren(branchrule) + ccall((:SCIPbranchruleGetNChildren, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleIsInitialized(branchrule) + ccall((:SCIPbranchruleIsInitialized, libscip), UInt32, (Ptr{SCIP_BRANCHRULE},), branchrule) +end diff --git a/src/wrapper/pub_compr.jl b/src/wrapper/pub_compr.jl new file mode 100644 index 00000000..d623a37b --- /dev/null +++ b/src/wrapper/pub_compr.jl @@ -0,0 +1,55 @@ +# Julia wrapper for header: /usr/include/scip/pub_compr.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPcomprComp(elem1, elem2) + ccall((:SCIPcomprComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPcomprCompName(elem1, elem2) + ccall((:SCIPcomprCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPcomprGetData(compr) + ccall((:SCIPcomprGetData, libscip), Ptr{SCIP_COMPRDATA}, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprSetData(compr, comprdata) + ccall((:SCIPcomprSetData, libscip), Cvoid, (Ptr{SCIP_COMPR}, Ptr{SCIP_COMPRDATA}), compr, comprdata) +end + +function SCIPcomprGetName(heur) + ccall((:SCIPcomprGetName, libscip), Cstring, (Ptr{SCIP_COMPR},), heur) +end + +function SCIPcomprGetDesc(compr) + ccall((:SCIPcomprGetDesc, libscip), Cstring, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprGetPriority(compr) + ccall((:SCIPcomprGetPriority, libscip), Cint, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprGetMinNodes(compr) + ccall((:SCIPcomprGetMinNodes, libscip), Cint, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprGetNCalls(compr) + ccall((:SCIPcomprGetNCalls, libscip), Clonglong, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprGetNFound(compr) + ccall((:SCIPcomprGetNFound, libscip), Clonglong, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprIsInitialized(compr) + ccall((:SCIPcomprIsInitialized, libscip), UInt32, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprGetSetupTime(compr) + ccall((:SCIPcomprGetSetupTime, libscip), Cdouble, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprGetTime(compr) + ccall((:SCIPcomprGetTime, libscip), Cdouble, (Ptr{SCIP_COMPR},), compr) +end diff --git a/src/wrapper/pub_conflict.jl b/src/wrapper/pub_conflict.jl new file mode 100644 index 00000000..857f44f5 --- /dev/null +++ b/src/wrapper/pub_conflict.jl @@ -0,0 +1,43 @@ +# Julia wrapper for header: /usr/include/scip/pub_conflict.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPconflicthdlrComp(elem1, elem2) + ccall((:SCIPconflicthdlrComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPconflicthdlrCompName(elem1, elem2) + ccall((:SCIPconflicthdlrCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPconflicthdlrGetData(conflicthdlr) + ccall((:SCIPconflicthdlrGetData, libscip), Ptr{SCIP_CONFLICTHDLRDATA}, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrSetData(conflicthdlr, conflicthdlrdata) + ccall((:SCIPconflicthdlrSetData, libscip), Cvoid, (Ptr{SCIP_CONFLICTHDLR}, Ptr{SCIP_CONFLICTHDLRDATA}), conflicthdlr, conflicthdlrdata) +end + +function SCIPconflicthdlrGetName(conflicthdlr) + ccall((:SCIPconflicthdlrGetName, libscip), Cstring, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrGetDesc(conflicthdlr) + ccall((:SCIPconflicthdlrGetDesc, libscip), Cstring, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrGetPriority(conflicthdlr) + ccall((:SCIPconflicthdlrGetPriority, libscip), Cint, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrIsInitialized(conflicthdlr) + ccall((:SCIPconflicthdlrIsInitialized, libscip), UInt32, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrGetSetupTime(conflicthdlr) + ccall((:SCIPconflicthdlrGetSetupTime, libscip), Cdouble, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrGetTime(conflicthdlr) + ccall((:SCIPconflicthdlrGetTime, libscip), Cdouble, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end diff --git a/src/wrapper/pub_cons.jl b/src/wrapper/pub_cons.jl new file mode 100644 index 00000000..955a0dd6 --- /dev/null +++ b/src/wrapper/pub_cons.jl @@ -0,0 +1,503 @@ +# Julia wrapper for header: /usr/include/scip/pub_cons.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPconshdlrCompSepa(elem1, elem2) + ccall((:SCIPconshdlrCompSepa, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPconshdlrCompEnfo(elem1, elem2) + ccall((:SCIPconshdlrCompEnfo, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPconshdlrCompCheck(elem1, elem2) + ccall((:SCIPconshdlrCompCheck, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPconshdlrGetName(conshdlr) + ccall((:SCIPconshdlrGetName, libscip), Cstring, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetDesc(conshdlr) + ccall((:SCIPconshdlrGetDesc, libscip), Cstring, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetData(conshdlr) + ccall((:SCIPconshdlrGetData, libscip), Ptr{SCIP_CONSHDLRDATA}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrSetData(conshdlr, conshdlrdata) + ccall((:SCIPconshdlrSetData, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONSHDLRDATA}), conshdlr, conshdlrdata) +end + +function SCIPconshdlrSetSepa(conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) + ccall((:SCIPconshdlrSetSepa, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, UInt32), conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) +end + +function SCIPconshdlrSetProp(conshdlr, consprop, propfreq, delayprop, timingmask) + ccall((:SCIPconshdlrSetProp, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, UInt32, SCIP_PROPTIMING), conshdlr, consprop, propfreq, delayprop, timingmask) +end + +function SCIPconshdlrSetEnforelax(conshdlr, consenforelax) + ccall((:SCIPconshdlrSetEnforelax, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), conshdlr, consenforelax) +end + +function SCIPconshdlrGetConss(conshdlr) + ccall((:SCIPconshdlrGetConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetEnfoConss(conshdlr) + ccall((:SCIPconshdlrGetEnfoConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetCheckConss(conshdlr) + ccall((:SCIPconshdlrGetCheckConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNConss(conshdlr) + ccall((:SCIPconshdlrGetNConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNEnfoConss(conshdlr) + ccall((:SCIPconshdlrGetNEnfoConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNCheckConss(conshdlr) + ccall((:SCIPconshdlrGetNCheckConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNActiveConss(conshdlr) + ccall((:SCIPconshdlrGetNActiveConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNEnabledConss(conshdlr) + ccall((:SCIPconshdlrGetNEnabledConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetSetupTime(conshdlr) + ccall((:SCIPconshdlrGetSetupTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetPresolTime(conshdlr) + ccall((:SCIPconshdlrGetPresolTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetSepaTime(conshdlr) + ccall((:SCIPconshdlrGetSepaTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetEnfoLPTime(conshdlr) + ccall((:SCIPconshdlrGetEnfoLPTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetEnfoPSTime(conshdlr) + ccall((:SCIPconshdlrGetEnfoPSTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetEnfoRelaxTime(conshdlr) + ccall((:SCIPconshdlrGetEnfoRelaxTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetPropTime(conshdlr) + ccall((:SCIPconshdlrGetPropTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetStrongBranchPropTime(conshdlr) + ccall((:SCIPconshdlrGetStrongBranchPropTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetCheckTime(conshdlr) + ccall((:SCIPconshdlrGetCheckTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetRespropTime(conshdlr) + ccall((:SCIPconshdlrGetRespropTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNSepaCalls(conshdlr) + ccall((:SCIPconshdlrGetNSepaCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNEnfoLPCalls(conshdlr) + ccall((:SCIPconshdlrGetNEnfoLPCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNEnfoPSCalls(conshdlr) + ccall((:SCIPconshdlrGetNEnfoPSCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNEnfoRelaxCalls(conshdlr) + ccall((:SCIPconshdlrGetNEnfoRelaxCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNPropCalls(conshdlr) + ccall((:SCIPconshdlrGetNPropCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNCheckCalls(conshdlr) + ccall((:SCIPconshdlrGetNCheckCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNRespropCalls(conshdlr) + ccall((:SCIPconshdlrGetNRespropCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNCutoffs(conshdlr) + ccall((:SCIPconshdlrGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNCutsFound(conshdlr) + ccall((:SCIPconshdlrGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNCutsApplied(conshdlr) + ccall((:SCIPconshdlrGetNCutsApplied, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNConssFound(conshdlr) + ccall((:SCIPconshdlrGetNConssFound, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNDomredsFound(conshdlr) + ccall((:SCIPconshdlrGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNChildren(conshdlr) + ccall((:SCIPconshdlrGetNChildren, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetMaxNActiveConss(conshdlr) + ccall((:SCIPconshdlrGetMaxNActiveConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetStartNActiveConss(conshdlr) + ccall((:SCIPconshdlrGetStartNActiveConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNFixedVars(conshdlr) + ccall((:SCIPconshdlrGetNFixedVars, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNAggrVars(conshdlr) + ccall((:SCIPconshdlrGetNAggrVars, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNChgVarTypes(conshdlr) + ccall((:SCIPconshdlrGetNChgVarTypes, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNChgBds(conshdlr) + ccall((:SCIPconshdlrGetNChgBds, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNAddHoles(conshdlr) + ccall((:SCIPconshdlrGetNAddHoles, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNDelConss(conshdlr) + ccall((:SCIPconshdlrGetNDelConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNAddConss(conshdlr) + ccall((:SCIPconshdlrGetNAddConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNUpgdConss(conshdlr) + ccall((:SCIPconshdlrGetNUpgdConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNChgCoefs(conshdlr) + ccall((:SCIPconshdlrGetNChgCoefs, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNChgSides(conshdlr) + ccall((:SCIPconshdlrGetNChgSides, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetNPresolCalls(conshdlr) + ccall((:SCIPconshdlrGetNPresolCalls, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetSepaPriority(conshdlr) + ccall((:SCIPconshdlrGetSepaPriority, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetEnfoPriority(conshdlr) + ccall((:SCIPconshdlrGetEnfoPriority, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetCheckPriority(conshdlr) + ccall((:SCIPconshdlrGetCheckPriority, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetSepaFreq(conshdlr) + ccall((:SCIPconshdlrGetSepaFreq, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetPropFreq(conshdlr) + ccall((:SCIPconshdlrGetPropFreq, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetEagerFreq(conshdlr) + ccall((:SCIPconshdlrGetEagerFreq, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrNeedsCons(conshdlr) + ccall((:SCIPconshdlrNeedsCons, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrDoesPresolve(conshdlr) + ccall((:SCIPconshdlrDoesPresolve, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrIsSeparationDelayed(conshdlr) + ccall((:SCIPconshdlrIsSeparationDelayed, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrIsPropagationDelayed(conshdlr) + ccall((:SCIPconshdlrIsPropagationDelayed, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrWasLPSeparationDelayed(conshdlr) + ccall((:SCIPconshdlrWasLPSeparationDelayed, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrWasSolSeparationDelayed(conshdlr) + ccall((:SCIPconshdlrWasSolSeparationDelayed, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrWasPropagationDelayed(conshdlr) + ccall((:SCIPconshdlrWasPropagationDelayed, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrIsInitialized(conshdlr) + ccall((:SCIPconshdlrIsInitialized, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrIsClonable(conshdlr) + ccall((:SCIPconshdlrIsClonable, libscip), UInt32, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetPropTiming(conshdlr) + ccall((:SCIPconshdlrGetPropTiming, libscip), SCIP_PROPTIMING, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconssetchgGetAddedConsData(conssetchg, conss, nconss) + ccall((:SCIPconssetchgGetAddedConsData, libscip), Cvoid, (Ptr{SCIP_CONSSETCHG}, Ptr{Ptr{Ptr{SCIP_CONS}}}, Ptr{Cint}), conssetchg, conss, nconss) +end + +function SCIPconshdlrSetPropTiming(conshdlr, proptiming) + ccall((:SCIPconshdlrSetPropTiming, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, SCIP_PROPTIMING), conshdlr, proptiming) +end + +function SCIPconshdlrGetPresolTiming(conshdlr) + ccall((:SCIPconshdlrGetPresolTiming, libscip), SCIP_PRESOLTIMING, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrSetPresolTiming(conshdlr, presoltiming) + ccall((:SCIPconshdlrSetPresolTiming, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, SCIP_PRESOLTIMING), conshdlr, presoltiming) +end + +function SCIPconsGetName(cons) + ccall((:SCIPconsGetName, libscip), Cstring, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetPos(cons) + ccall((:SCIPconsGetPos, libscip), Cint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetHdlr(cons) + ccall((:SCIPconsGetHdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetData(cons) + ccall((:SCIPconsGetData, libscip), Ptr{SCIP_CONSDATA}, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetNUses(cons) + ccall((:SCIPconsGetNUses, libscip), Cint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetActiveDepth(cons) + ccall((:SCIPconsGetActiveDepth, libscip), Cint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetValidDepth(cons) + ccall((:SCIPconsGetValidDepth, libscip), Cint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsActive(cons) + ccall((:SCIPconsIsActive, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsUpdatedeactivate(cons) + ccall((:SCIPconsIsUpdatedeactivate, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsEnabled(cons) + ccall((:SCIPconsIsEnabled, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsSeparationEnabled(cons) + ccall((:SCIPconsIsSeparationEnabled, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsPropagationEnabled(cons) + ccall((:SCIPconsIsPropagationEnabled, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsDeleted(cons) + ccall((:SCIPconsIsDeleted, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsObsolete(cons) + ccall((:SCIPconsIsObsolete, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsConflict(cons) + ccall((:SCIPconsIsConflict, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetAge(cons) + ccall((:SCIPconsGetAge, libscip), Cdouble, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsInitial(cons) + ccall((:SCIPconsIsInitial, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsSeparated(cons) + ccall((:SCIPconsIsSeparated, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsEnforced(cons) + ccall((:SCIPconsIsEnforced, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsChecked(cons) + ccall((:SCIPconsIsChecked, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsMarkedPropagate(cons) + ccall((:SCIPconsIsMarkedPropagate, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsPropagated(cons) + ccall((:SCIPconsIsPropagated, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsGlobal(cons) + ccall((:SCIPconsIsGlobal, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLocal(cons) + ccall((:SCIPconsIsLocal, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsModifiable(cons) + ccall((:SCIPconsIsModifiable, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsDynamic(cons) + ccall((:SCIPconsIsDynamic, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsRemovable(cons) + ccall((:SCIPconsIsRemovable, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsStickingAtNode(cons) + ccall((:SCIPconsIsStickingAtNode, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsInProb(cons) + ccall((:SCIPconsIsInProb, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsOriginal(cons) + ccall((:SCIPconsIsOriginal, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsTransformed(cons) + ccall((:SCIPconsIsTransformed, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLockedPos(cons) + ccall((:SCIPconsIsLockedPos, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLockedNeg(cons) + ccall((:SCIPconsIsLockedNeg, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLocked(cons) + ccall((:SCIPconsIsLocked, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetNLocksPos(cons) + ccall((:SCIPconsGetNLocksPos, libscip), Cint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetNLocksNeg(cons) + ccall((:SCIPconsGetNLocksNeg, libscip), Cint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLockedTypePos(cons, locktype) + ccall((:SCIPconsIsLockedTypePos, libscip), UInt32, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) +end + +function SCIPconsIsLockedTypeNeg(cons, locktype) + ccall((:SCIPconsIsLockedTypeNeg, libscip), UInt32, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) +end + +function SCIPconsIsLockedType(cons, locktype) + ccall((:SCIPconsIsLockedType, libscip), UInt32, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) +end + +function SCIPconsGetNLocksTypePos(cons, locktype) + ccall((:SCIPconsGetNLocksTypePos, libscip), Cint, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) +end + +function SCIPconsGetNLocksTypeNeg(cons, locktype) + ccall((:SCIPconsGetNLocksTypeNeg, libscip), Cint, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) +end + +function SCIPconsIsAdded(cons) + ccall((:SCIPconsIsAdded, libscip), UInt32, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsAddUpgradeLocks(cons, nlocks) + ccall((:SCIPconsAddUpgradeLocks, libscip), Cvoid, (Ptr{SCIP_CONS}, Cint), cons, nlocks) +end + +function SCIPconsGetNUpgradeLocks(cons) + ccall((:SCIPconsGetNUpgradeLocks, libscip), Cint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPlinConsStatsCreate(scip, linconsstats) + ccall((:SCIPlinConsStatsCreate, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_LINCONSSTATS}}), scip, linconsstats) +end + +function SCIPlinConsStatsFree(scip, linconsstats) + ccall((:SCIPlinConsStatsFree, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Ptr{SCIP_LINCONSSTATS}}), scip, linconsstats) +end + +function SCIPlinConsStatsReset(linconsstats) + ccall((:SCIPlinConsStatsReset, libscip), Cvoid, (Ptr{SCIP_LINCONSSTATS},), linconsstats) +end + +function SCIPlinConsStatsGetTypeCount(linconsstats, linconstype) + ccall((:SCIPlinConsStatsGetTypeCount, libscip), Cint, (Ptr{SCIP_LINCONSSTATS}, SCIP_LINCONSTYPE), linconsstats, linconstype) +end + +function SCIPlinConsStatsGetSum(linconsstats) + ccall((:SCIPlinConsStatsGetSum, libscip), Cint, (Ptr{SCIP_LINCONSSTATS},), linconsstats) +end + +function SCIPlinConsStatsIncTypeCount(linconsstats, linconstype, increment) + ccall((:SCIPlinConsStatsIncTypeCount, libscip), Cvoid, (Ptr{SCIP_LINCONSSTATS}, SCIP_LINCONSTYPE, Cint), linconsstats, linconstype, increment) +end + +function SCIPprintLinConsStats(scip, file, linconsstats) + ccall((:SCIPprintLinConsStats, libscip), Cvoid, (Ptr{SCIP_}, Ptr{FILE}, Ptr{SCIP_LINCONSSTATS}), scip, file, linconsstats) +end diff --git a/src/wrapper/pub_cutpool.jl b/src/wrapper/pub_cutpool.jl new file mode 100644 index 00000000..66368660 --- /dev/null +++ b/src/wrapper/pub_cutpool.jl @@ -0,0 +1,39 @@ +# Julia wrapper for header: /usr/include/scip/pub_cutpool.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPcutGetRow() + ccall((:SCIPcutGetRow, libscip), Ptr{Cint}, ()) +end + +function SCIPcutGetAge(cut) + ccall((:SCIPcutGetAge, libscip), Cint, (Ptr{SCIP_CUT},), cut) +end + +function SCIPcutGetLPActivityQuot(cut) + ccall((:SCIPcutGetLPActivityQuot, libscip), Cdouble, (Ptr{SCIP_CUT},), cut) +end + +function SCIPcutpoolGetCuts(cutpool) + ccall((:SCIPcutpoolGetCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP_CUTPOOL},), cutpool) +end + +function SCIPcutpoolGetNCuts(cutpool) + ccall((:SCIPcutpoolGetNCuts, libscip), Cint, (Ptr{SCIP_CUTPOOL},), cutpool) +end + +function SCIPcutpoolGetMaxNCuts(cutpool) + ccall((:SCIPcutpoolGetMaxNCuts, libscip), Cint, (Ptr{SCIP_CUTPOOL},), cutpool) +end + +function SCIPcutpoolGetTime(cutpool) + ccall((:SCIPcutpoolGetTime, libscip), Cdouble, (Ptr{SCIP_CUTPOOL},), cutpool) +end + +function SCIPcutpoolGetNCalls(cutpool) + ccall((:SCIPcutpoolGetNCalls, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) +end + +function SCIPcutpoolGetNCutsFound(cutpool) + ccall((:SCIPcutpoolGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) +end diff --git a/src/wrapper/pub_dialog.jl b/src/wrapper/pub_dialog.jl new file mode 100644 index 00000000..320bf11b --- /dev/null +++ b/src/wrapper/pub_dialog.jl @@ -0,0 +1,91 @@ +# Julia wrapper for header: /usr/include/scip/pub_dialog.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPdialoghdlrGetRoot(dialoghdlr) + ccall((:SCIPdialoghdlrGetRoot, libscip), Ptr{SCIP_DIALOG}, (Ptr{SCIP_DIALOGHDLR},), dialoghdlr) +end + +function SCIPdialoghdlrClearBuffer(dialoghdlr) + ccall((:SCIPdialoghdlrClearBuffer, libscip), Cvoid, (Ptr{SCIP_DIALOGHDLR},), dialoghdlr) +end + +function SCIPdialoghdlrIsBufferEmpty(dialoghdlr) + ccall((:SCIPdialoghdlrIsBufferEmpty, libscip), UInt32, (Ptr{SCIP_DIALOGHDLR},), dialoghdlr) +end + +function SCIPdialoghdlrGetLine(dialoghdlr, dialog, prompt, inputline, endoffile) + ccall((:SCIPdialoghdlrGetLine, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Cstring, Ptr{Cstring}, Ptr{UInt32}), dialoghdlr, dialog, prompt, inputline, endoffile) +end + +function SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, inputword, endoffile) + ccall((:SCIPdialoghdlrGetWord, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Cstring, Ptr{Cstring}, Ptr{UInt32}), dialoghdlr, dialog, prompt, inputword, endoffile) +end + +function SCIPdialoghdlrAddInputLine(dialoghdlr, inputline) + ccall((:SCIPdialoghdlrAddInputLine, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Cstring), dialoghdlr, inputline) +end + +function SCIPdialoghdlrAddHistory(dialoghdlr, dialog, command, escapecommand) + ccall((:SCIPdialoghdlrAddHistory, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Cstring, UInt32), dialoghdlr, dialog, command, escapecommand) +end + +function SCIPdialogHasEntry(dialog, entryname) + ccall((:SCIPdialogHasEntry, libscip), UInt32, (Ptr{SCIP_DIALOG}, Cstring), dialog, entryname) +end + +function SCIPdialogFindEntry(dialog, entryname, subdialog) + ccall((:SCIPdialogFindEntry, libscip), Cint, (Ptr{SCIP_DIALOG}, Cstring, Ptr{Ptr{SCIP_DIALOG}}), dialog, entryname, subdialog) +end + +function SCIPdialogDisplayMenu(dialog, scip) + ccall((:SCIPdialogDisplayMenu, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOG}, Ptr{SCIP_}), dialog, scip) +end + +function SCIPdialogDisplayMenuEntry(dialog, scip) + ccall((:SCIPdialogDisplayMenuEntry, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOG}, Ptr{SCIP_}), dialog, scip) +end + +function SCIPdialogDisplayCompletions(dialog, scip, entryname) + ccall((:SCIPdialogDisplayCompletions, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOG}, Ptr{SCIP_}, Cstring), dialog, scip, entryname) +end + +function SCIPdialogGetPath(dialog, sepchar, path) + ccall((:SCIPdialogGetPath, libscip), Cvoid, (Ptr{SCIP_DIALOG}, UInt8, Cstring), dialog, sepchar, path) +end + +function SCIPdialogGetName(dialog) + ccall((:SCIPdialogGetName, libscip), Cstring, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogGetDesc(dialog) + ccall((:SCIPdialogGetDesc, libscip), Cstring, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogIsSubmenu(dialog) + ccall((:SCIPdialogIsSubmenu, libscip), UInt32, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogGetParent(dialog) + ccall((:SCIPdialogGetParent, libscip), Ptr{SCIP_DIALOG}, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogGetSubdialogs(dialog) + ccall((:SCIPdialogGetSubdialogs, libscip), Ptr{Ptr{SCIP_DIALOG}}, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogGetNSubdialogs(dialog) + ccall((:SCIPdialogGetNSubdialogs, libscip), Cint, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogGetData(dialog) + ccall((:SCIPdialogGetData, libscip), Ptr{SCIP_DIALOGDATA}, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogSetData(dialog, dialogdata) + ccall((:SCIPdialogSetData, libscip), Cvoid, (Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGDATA}), dialog, dialogdata) +end + +function SCIPdialogWriteHistory(filename) + ccall((:SCIPdialogWriteHistory, libscip), SCIP_RETCODE, (Cstring,), filename) +end diff --git a/src/wrapper/pub_disp.jl b/src/wrapper/pub_disp.jl new file mode 100644 index 00000000..9bc7c06b --- /dev/null +++ b/src/wrapper/pub_disp.jl @@ -0,0 +1,55 @@ +# Julia wrapper for header: /usr/include/scip/pub_disp.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPdispGetData(disp) + ccall((:SCIPdispGetData, libscip), Ptr{SCIP_DISPDATA}, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispSetData(disp, dispdata) + ccall((:SCIPdispSetData, libscip), Cvoid, (Ptr{SCIP_DISP}, Ptr{SCIP_DISPDATA}), disp, dispdata) +end + +function SCIPdispGetName(disp) + ccall((:SCIPdispGetName, libscip), Cstring, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispGetDesc(disp) + ccall((:SCIPdispGetDesc, libscip), Cstring, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispGetHeader(disp) + ccall((:SCIPdispGetHeader, libscip), Cstring, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispGetWidth(disp) + ccall((:SCIPdispGetWidth, libscip), Cint, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispGetPriority(disp) + ccall((:SCIPdispGetPriority, libscip), Cint, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispGetPosition(disp) + ccall((:SCIPdispGetPosition, libscip), Cint, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispGetStatus(disp) + ccall((:SCIPdispGetStatus, libscip), SCIP_DISPSTATUS, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispIsInitialized(disp) + ccall((:SCIPdispIsInitialized, libscip), UInt32, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispLongint(messagehdlr, file, val, width) + ccall((:SCIPdispLongint, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{FILE}, Clonglong, Cint), messagehdlr, file, val, width) +end + +function SCIPdispInt(messagehdlr, file, val, width) + ccall((:SCIPdispInt, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{FILE}, Cint, Cint), messagehdlr, file, val, width) +end + +function SCIPdispTime(messagehdlr, file, val, width) + ccall((:SCIPdispTime, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{FILE}, Cdouble, Cint), messagehdlr, file, val, width) +end diff --git a/src/wrapper/pub_event.jl b/src/wrapper/pub_event.jl new file mode 100644 index 00000000..8eef8f6b --- /dev/null +++ b/src/wrapper/pub_event.jl @@ -0,0 +1,103 @@ +# Julia wrapper for header: /usr/include/scip/pub_event.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPeventhdlrGetName(eventhdlr) + ccall((:SCIPeventhdlrGetName, libscip), Cstring, (Ptr{SCIP_EVENTHDLR},), eventhdlr) +end + +function SCIPeventhdlrGetData(eventhdlr) + ccall((:SCIPeventhdlrGetData, libscip), Ptr{SCIP_EVENTHDLRDATA}, (Ptr{SCIP_EVENTHDLR},), eventhdlr) +end + +function SCIPeventhdlrSetData(eventhdlr, eventhdlrdata) + ccall((:SCIPeventhdlrSetData, libscip), Cvoid, (Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTHDLRDATA}), eventhdlr, eventhdlrdata) +end + +function SCIPeventhdlrIsInitialized(eventhdlr) + ccall((:SCIPeventhdlrIsInitialized, libscip), UInt32, (Ptr{SCIP_EVENTHDLR},), eventhdlr) +end + +function SCIPeventhdlrGetSetupTime(eventhdlr) + ccall((:SCIPeventhdlrGetSetupTime, libscip), Cdouble, (Ptr{SCIP_EVENTHDLR},), eventhdlr) +end + +function SCIPeventhdlrGetTime(eventhdlr) + ccall((:SCIPeventhdlrGetTime, libscip), Cdouble, (Ptr{SCIP_EVENTHDLR},), eventhdlr) +end + +function SCIPeventGetType(event) + ccall((:SCIPeventGetType, libscip), SCIP_EVENTTYPE, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetVar(event) + ccall((:SCIPeventGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetOldobj(event) + ccall((:SCIPeventGetOldobj, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetNewobj(event) + ccall((:SCIPeventGetNewobj, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetOldbound(event) + ccall((:SCIPeventGetOldbound, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetNewbound(event) + ccall((:SCIPeventGetNewbound, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetNode(event) + ccall((:SCIPeventGetNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetSol(event) + ccall((:SCIPeventGetSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetHoleLeft(event) + ccall((:SCIPeventGetHoleLeft, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetHoleRight(event) + ccall((:SCIPeventGetHoleRight, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRow(event) + ccall((:SCIPeventGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRowCol(event) + ccall((:SCIPeventGetRowCol, libscip), Ptr{SCIP_COL}, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRowOldCoefVal(event) + ccall((:SCIPeventGetRowOldCoefVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRowNewCoefVal(event) + ccall((:SCIPeventGetRowNewCoefVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRowOldConstVal(event) + ccall((:SCIPeventGetRowOldConstVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRowNewConstVal(event) + ccall((:SCIPeventGetRowNewConstVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRowSide(event) + ccall((:SCIPeventGetRowSide, libscip), SCIP_SIDETYPE, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRowOldSideVal(event) + ccall((:SCIPeventGetRowOldSideVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetRowNewSideVal(event) + ccall((:SCIPeventGetRowNewSideVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end diff --git a/src/wrapper/pub_fileio.jl b/src/wrapper/pub_fileio.jl new file mode 100644 index 00000000..8eba6d1d --- /dev/null +++ b/src/wrapper/pub_fileio.jl @@ -0,0 +1,59 @@ +# Julia wrapper for header: /usr/include/scip/pub_fileio.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPfopen(path, mode) + ccall((:SCIPfopen, libscip), Ptr{SCIP_FILE}, (Cstring, Cstring), path, mode) +end + +function SCIPfdopen(fildes, mode) + ccall((:SCIPfdopen, libscip), Ptr{SCIP_FILE}, (Cint, Cstring), fildes, mode) +end + +function SCIPfread(ptr, size, nmemb, stream) + ccall((:SCIPfread, libscip), Csize_t, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{SCIP_FILE}), ptr, size, nmemb, stream) +end + +function SCIPfwrite(ptr, size, nmemb, stream) + ccall((:SCIPfwrite, libscip), Csize_t, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{SCIP_FILE}), ptr, size, nmemb, stream) +end + +function SCIPfputc(c, stream) + ccall((:SCIPfputc, libscip), Cint, (Cint, Ptr{SCIP_FILE}), c, stream) +end + +function SCIPfputs(s, stream) + ccall((:SCIPfputs, libscip), Cint, (Cstring, Ptr{SCIP_FILE}), s, stream) +end + +function SCIPfgetc(stream) + ccall((:SCIPfgetc, libscip), Cint, (Ptr{SCIP_FILE},), stream) +end + +function SCIPfgets(s, size, stream) + ccall((:SCIPfgets, libscip), Cstring, (Cstring, Cint, Ptr{SCIP_FILE}), s, size, stream) +end + +function SCIPfflush(stream) + ccall((:SCIPfflush, libscip), Cint, (Ptr{SCIP_FILE},), stream) +end + +function SCIPfseek(stream, offset, whence) + ccall((:SCIPfseek, libscip), Cint, (Ptr{SCIP_FILE}, Clong, Cint), stream, offset, whence) +end + +function SCIPrewind(stream) + ccall((:SCIPrewind, libscip), Cvoid, (Ptr{SCIP_FILE},), stream) +end + +function SCIPftell(stream) + ccall((:SCIPftell, libscip), Clong, (Ptr{SCIP_FILE},), stream) +end + +function SCIPfeof(stream) + ccall((:SCIPfeof, libscip), Cint, (Ptr{SCIP_FILE},), stream) +end + +function SCIPfclose(fp) + ccall((:SCIPfclose, libscip), Cint, (Ptr{SCIP_FILE},), fp) +end diff --git a/src/wrapper/pub_heur.jl b/src/wrapper/pub_heur.jl new file mode 100644 index 00000000..b3a815a7 --- /dev/null +++ b/src/wrapper/pub_heur.jl @@ -0,0 +1,235 @@ +# Julia wrapper for header: /usr/include/scip/pub_heur.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPheurComp(elem1, elem2) + ccall((:SCIPheurComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPheurCompName(elem1, elem2) + ccall((:SCIPheurCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPheurGetData(heur) + ccall((:SCIPheurGetData, libscip), Ptr{SCIP_HEURDATA}, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurSetData(heur, heurdata) + ccall((:SCIPheurSetData, libscip), Cvoid, (Ptr{SCIP_HEUR}, Ptr{SCIP_HEURDATA}), heur, heurdata) +end + +function SCIPheurGetName(heur) + ccall((:SCIPheurGetName, libscip), Cstring, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetDesc(heur) + ccall((:SCIPheurGetDesc, libscip), Cstring, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetDispchar(heur) + ccall((:SCIPheurGetDispchar, libscip), UInt8, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetTimingmask(heur) + ccall((:SCIPheurGetTimingmask, libscip), SCIP_HEURTIMING, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurSetTimingmask(heur, timingmask) + ccall((:SCIPheurSetTimingmask, libscip), Cvoid, (Ptr{SCIP_HEUR}, SCIP_HEURTIMING), heur, timingmask) +end + +function SCIPheurUsesSubscip(heur) + ccall((:SCIPheurUsesSubscip, libscip), UInt32, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetPriority(heur) + ccall((:SCIPheurGetPriority, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetFreq(heur) + ccall((:SCIPheurGetFreq, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurSetFreq(heur, freq) + ccall((:SCIPheurSetFreq, libscip), Cvoid, (Ptr{SCIP_HEUR}, Cint), heur, freq) +end + +function SCIPheurGetFreqofs(heur) + ccall((:SCIPheurGetFreqofs, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetMaxdepth(heur) + ccall((:SCIPheurGetMaxdepth, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetNCalls(heur) + ccall((:SCIPheurGetNCalls, libscip), Clonglong, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetNSolsFound(heur) + ccall((:SCIPheurGetNSolsFound, libscip), Clonglong, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetNBestSolsFound(heur) + ccall((:SCIPheurGetNBestSolsFound, libscip), Clonglong, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurIsInitialized(heur) + ccall((:SCIPheurIsInitialized, libscip), UInt32, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetSetupTime(heur) + ccall((:SCIPheurGetSetupTime, libscip), Cdouble, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetTime(heur) + ccall((:SCIPheurGetTime, libscip), Cdouble, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetDivesets(heur) + ccall((:SCIPheurGetDivesets, libscip), Ptr{Ptr{SCIP_DIVESET}}, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetNDivesets(heur) + ccall((:SCIPheurGetNDivesets, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPdivesetGetHeur(diveset) + ccall((:SCIPdivesetGetHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetWorkSolution(diveset) + ccall((:SCIPdivesetGetWorkSolution, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetSetWorkSolution(diveset, sol) + ccall((:SCIPdivesetSetWorkSolution, libscip), Cvoid, (Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}), diveset, sol) +end + +function SCIPdivesetGetName(diveset) + ccall((:SCIPdivesetGetName, libscip), Cstring, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetMinRelDepth(diveset) + ccall((:SCIPdivesetGetMinRelDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetMaxRelDepth(diveset) + ccall((:SCIPdivesetGetMaxRelDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetSolSuccess(diveset) + ccall((:SCIPdivesetGetSolSuccess, libscip), Clonglong, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetNCalls(diveset) + ccall((:SCIPdivesetGetNCalls, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetNSolutionCalls(diveset) + ccall((:SCIPdivesetGetNSolutionCalls, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetMinDepth(diveset) + ccall((:SCIPdivesetGetMinDepth, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetMaxDepth(diveset) + ccall((:SCIPdivesetGetMaxDepth, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetAvgDepth(diveset) + ccall((:SCIPdivesetGetAvgDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetMinSolutionDepth(diveset) + ccall((:SCIPdivesetGetMinSolutionDepth, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetMaxSolutionDepth(diveset) + ccall((:SCIPdivesetGetMaxSolutionDepth, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetAvgSolutionDepth(diveset) + ccall((:SCIPdivesetGetAvgSolutionDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetNLPIterations(diveset) + ccall((:SCIPdivesetGetNLPIterations, libscip), Clonglong, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetNProbingNodes(diveset) + ccall((:SCIPdivesetGetNProbingNodes, libscip), Clonglong, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetNBacktracks(diveset) + ccall((:SCIPdivesetGetNBacktracks, libscip), Clonglong, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetNConflicts(diveset) + ccall((:SCIPdivesetGetNConflicts, libscip), Clonglong, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetNSols(diveset) + ccall((:SCIPdivesetGetNSols, libscip), Clonglong, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetMaxLPIterQuot(diveset) + ccall((:SCIPdivesetGetMaxLPIterQuot, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetMaxLPIterOffset(diveset) + ccall((:SCIPdivesetGetMaxLPIterOffset, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetUbQuotNoSol(diveset) + ccall((:SCIPdivesetGetUbQuotNoSol, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetAvgQuotNoSol(diveset) + ccall((:SCIPdivesetGetAvgQuotNoSol, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetUbQuot(diveset) + ccall((:SCIPdivesetGetUbQuot, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetAvgQuot(diveset) + ccall((:SCIPdivesetGetAvgQuot, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetUseBacktrack(diveset) + ccall((:SCIPdivesetUseBacktrack, libscip), UInt32, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetLPSolveFreq(diveset) + ccall((:SCIPdivesetGetLPSolveFreq, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetGetLPResolveDomChgQuot(diveset) + ccall((:SCIPdivesetGetLPResolveDomChgQuot, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetUseOnlyLPBranchcands(diveset) + ccall((:SCIPdivesetUseOnlyLPBranchcands, libscip), UInt32, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetSupportsType(diveset, divetype) + ccall((:SCIPdivesetSupportsType, libscip), UInt32, (Ptr{SCIP_DIVESET}, SCIP_DIVETYPE), diveset, divetype) +end + +function SCIPdivesetGetRandnumgen(diveset) + ccall((:SCIPdivesetGetRandnumgen, libscip), Ptr{SCIP_RANDNUMGEN}, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPvariablegraphBreadthFirst(scip, vargraph, startvars, nstartvars, distances, maxdistance, maxvars, maxbinintvars) + ccall((:SCIPvariablegraphBreadthFirst, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VGRAPH}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Cint, Cint, Cint), scip, vargraph, startvars, nstartvars, distances, maxdistance, maxvars, maxbinintvars) +end + +function SCIPvariableGraphCreate(scip, vargraph, relaxdenseconss, relaxdensity, nrelaxedconstraints) + ccall((:SCIPvariableGraphCreate, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VGRAPH}}, UInt32, Cdouble, Ptr{Cint}), scip, vargraph, relaxdenseconss, relaxdensity, nrelaxedconstraints) +end + +function SCIPvariableGraphFree(scip, vargraph) + ccall((:SCIPvariableGraphFree, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Ptr{SCIP_VGRAPH}}), scip, vargraph) +end diff --git a/src/wrapper/pub_history.jl b/src/wrapper/pub_history.jl new file mode 100644 index 00000000..274a7d00 --- /dev/null +++ b/src/wrapper/pub_history.jl @@ -0,0 +1,23 @@ +# Julia wrapper for header: /usr/include/scip/pub_history.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPhistoryGetVSIDS(history, dir) + ccall((:SCIPhistoryGetVSIDS, libscip), Cdouble, (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), history, dir) +end + +function SCIPhistoryGetCutoffSum(history, dir) + ccall((:SCIPhistoryGetCutoffSum, libscip), Cdouble, (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), history, dir) +end + +function SCIPvaluehistoryGetNValues(valuehistory) + ccall((:SCIPvaluehistoryGetNValues, libscip), Cint, (Ptr{SCIP_VALUEHISTORY},), valuehistory) +end + +function SCIPvaluehistoryGetHistories(valuehistory) + ccall((:SCIPvaluehistoryGetHistories, libscip), Ptr{Ptr{SCIP_HISTORY}}, (Ptr{SCIP_VALUEHISTORY},), valuehistory) +end + +function SCIPvaluehistoryGetValues(valuehistory) + ccall((:SCIPvaluehistoryGetValues, libscip), Ptr{Cdouble}, (Ptr{SCIP_VALUEHISTORY},), valuehistory) +end diff --git a/src/wrapper/pub_implics.jl b/src/wrapper/pub_implics.jl new file mode 100644 index 00000000..43f9dd8a --- /dev/null +++ b/src/wrapper/pub_implics.jl @@ -0,0 +1,39 @@ +# Julia wrapper for header: /usr/include/scip/pub_implics.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPcliqueSearchVar(clique, var, value) + ccall((:SCIPcliqueSearchVar, libscip), Cint, (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, UInt32), clique, var, value) +end + +function SCIPcliqueHasVar(clique, var, value) + ccall((:SCIPcliqueHasVar, libscip), UInt32, (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, UInt32), clique, var, value) +end + +function SCIPcliqueGetNVars(clique) + ccall((:SCIPcliqueGetNVars, libscip), Cint, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueGetVars(clique) + ccall((:SCIPcliqueGetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueGetValues(clique) + ccall((:SCIPcliqueGetValues, libscip), Ptr{UInt32}, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueGetId(clique) + ccall((:SCIPcliqueGetId, libscip), UInt32, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueGetIndex(clique) + ccall((:SCIPcliqueGetIndex, libscip), Cint, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueIsCleanedUp(clique) + ccall((:SCIPcliqueIsCleanedUp, libscip), UInt32, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueIsEquation(clique) + ccall((:SCIPcliqueIsEquation, libscip), UInt32, (Ptr{SCIP_CLIQUE},), clique) +end diff --git a/src/wrapper/pub_lp.jl b/src/wrapper/pub_lp.jl new file mode 100644 index 00000000..d0a6ebbd --- /dev/null +++ b/src/wrapper/pub_lp.jl @@ -0,0 +1,243 @@ +# Julia wrapper for header: /usr/include/scip/pub_lp.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPcolSort(col) + ccall((:SCIPcolSort, libscip), Cvoid, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetObj(col) + ccall((:SCIPcolGetObj, libscip), Cdouble, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetLb(col) + ccall((:SCIPcolGetLb, libscip), Cdouble, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetUb(col) + ccall((:SCIPcolGetUb, libscip), Cdouble, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetBestBound(col) + ccall((:SCIPcolGetBestBound, libscip), Cdouble, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetPrimsol(col) + ccall((:SCIPcolGetPrimsol, libscip), Cdouble, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetMinPrimsol(col) + ccall((:SCIPcolGetMinPrimsol, libscip), Cdouble, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetMaxPrimsol(col) + ccall((:SCIPcolGetMaxPrimsol, libscip), Cdouble, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetBasisStatus(col) + ccall((:SCIPcolGetBasisStatus, libscip), SCIP_BASESTAT, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetVar(col) + ccall((:SCIPcolGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetIndex(col) + ccall((:SCIPcolGetIndex, libscip), Cint, (Ptr{SCIP_COL},), col) +end + +function SCIPcolIsIntegral(col) + ccall((:SCIPcolIsIntegral, libscip), UInt32, (Ptr{SCIP_COL},), col) +end + +function SCIPcolIsRemovable(col) + ccall((:SCIPcolIsRemovable, libscip), UInt32, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetLPPos(col) + ccall((:SCIPcolGetLPPos, libscip), Cint, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetLPDepth(col) + ccall((:SCIPcolGetLPDepth, libscip), Cint, (Ptr{SCIP_COL},), col) +end + +function SCIPcolIsInLP(col) + ccall((:SCIPcolIsInLP, libscip), UInt32, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetNNonz(col) + ccall((:SCIPcolGetNNonz, libscip), Cint, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetNLPNonz(col) + ccall((:SCIPcolGetNLPNonz, libscip), Cint, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetRows(col) + ccall((:SCIPcolGetRows, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetVals(col) + ccall((:SCIPcolGetVals, libscip), Ptr{Cdouble}, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetStrongbranchNode(col) + ccall((:SCIPcolGetStrongbranchNode, libscip), Clonglong, (Ptr{SCIP_COL},), col) +end + +function SCIPcolGetNStrongbranchs(col) + ccall((:SCIPcolGetNStrongbranchs, libscip), Cint, (Ptr{SCIP_COL},), col) +end + +function SCIPboundtypeOpposite(boundtype) + ccall((:SCIPboundtypeOpposite, libscip), SCIP_BOUNDTYPE, (SCIP_BOUNDTYPE,), boundtype) +end + +function SCIProwComp(elem1, elem2) + ccall((:SCIProwComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIProwLock(row) + ccall((:SCIProwLock, libscip), Cvoid, (Ptr{SCIP_ROW},), row) +end + +function SCIProwUnlock(row) + ccall((:SCIProwUnlock, libscip), Cvoid, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetScalarProduct(row1, row2) + ccall((:SCIProwGetScalarProduct, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}), row1, row2) +end + +function SCIProwGetParallelism(row1, row2, orthofunc) + ccall((:SCIProwGetParallelism, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, UInt8), row1, row2, orthofunc) +end + +function SCIProwGetOrthogonality(row1, row2, orthofunc) + ccall((:SCIProwGetOrthogonality, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, UInt8), row1, row2, orthofunc) +end + +function SCIProwSort(row) + ccall((:SCIProwSort, libscip), Cvoid, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetNNonz(row) + ccall((:SCIProwGetNNonz, libscip), Cint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetNLPNonz(row) + ccall((:SCIProwGetNLPNonz, libscip), Cint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetCols(row) + ccall((:SCIProwGetCols, libscip), Ptr{Ptr{SCIP_COL}}, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetVals(row) + ccall((:SCIProwGetVals, libscip), Ptr{Cdouble}, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetConstant(row) + ccall((:SCIProwGetConstant, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetNorm(row) + ccall((:SCIProwGetNorm, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetSumNorm(row) + ccall((:SCIProwGetSumNorm, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetLhs(row) + ccall((:SCIProwGetLhs, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetRhs(row) + ccall((:SCIProwGetRhs, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetDualsol(row) + ccall((:SCIProwGetDualsol, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetDualfarkas(row) + ccall((:SCIProwGetDualfarkas, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetBasisStatus(row) + ccall((:SCIProwGetBasisStatus, libscip), SCIP_BASESTAT, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetName(row) + ccall((:SCIProwGetName, libscip), Cstring, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetIndex(row) + ccall((:SCIProwGetIndex, libscip), Cint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetAge(row) + ccall((:SCIProwGetAge, libscip), Cint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetRank(row) + ccall((:SCIProwGetRank, libscip), Cint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsIntegral(row) + ccall((:SCIProwIsIntegral, libscip), UInt32, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsLocal(row) + ccall((:SCIProwIsLocal, libscip), UInt32, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsModifiable(row) + ccall((:SCIProwIsModifiable, libscip), UInt32, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsRemovable(row) + ccall((:SCIProwIsRemovable, libscip), UInt32, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetOrigintype(row) + ccall((:SCIProwGetOrigintype, libscip), SCIP_ROWORIGINTYPE, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetOriginCons(row) + ccall((:SCIProwGetOriginCons, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetOriginSepa(row) + ccall((:SCIProwGetOriginSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsInGlobalCutpool(row) + ccall((:SCIProwIsInGlobalCutpool, libscip), UInt32, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetLPPos(row) + ccall((:SCIProwGetLPPos, libscip), Cint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetLPDepth(row) + ccall((:SCIProwGetLPDepth, libscip), Cint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsInLP(row) + ccall((:SCIProwIsInLP, libscip), UInt32, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetActiveLPCount(row) + ccall((:SCIProwGetActiveLPCount, libscip), Clonglong, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetNLPsAfterCreation(row) + ccall((:SCIProwGetNLPsAfterCreation, libscip), Clonglong, (Ptr{SCIP_ROW},), row) +end + +function SCIProwChgRank(row, rank) + ccall((:SCIProwChgRank, libscip), Cvoid, (Ptr{SCIP_ROW}, Cint), row, rank) +end diff --git a/src/wrapper/pub_matrix.jl b/src/wrapper/pub_matrix.jl new file mode 100644 index 00000000..790b0dde --- /dev/null +++ b/src/wrapper/pub_matrix.jl @@ -0,0 +1,135 @@ +# Julia wrapper for header: /usr/include/scip/pub_matrix.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPmatrixGetColValPtr(matrix, col) + ccall((:SCIPmatrixGetColValPtr, libscip), Ptr{Cdouble}, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetColIdxPtr(matrix, col) + ccall((:SCIPmatrixGetColIdxPtr, libscip), Ptr{Cint}, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetColNNonzs(matrix, col) + ccall((:SCIPmatrixGetColNNonzs, libscip), Cint, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetNColumns(matrix) + ccall((:SCIPmatrixGetNColumns, libscip), Cint, (Ptr{SCIP_MATRIX},), matrix) +end + +function SCIPmatrixGetColUb(matrix, col) + ccall((:SCIPmatrixGetColUb, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetColLb(matrix, col) + ccall((:SCIPmatrixGetColLb, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetColNUplocks(matrix, col) + ccall((:SCIPmatrixGetColNUplocks, libscip), Cint, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetColNDownlocks(matrix, col) + ccall((:SCIPmatrixGetColNDownlocks, libscip), Cint, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetVar(matrix, col) + ccall((:SCIPmatrixGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetColName(matrix, col) + ccall((:SCIPmatrixGetColName, libscip), Cstring, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetRowValPtr(matrix, row) + ccall((:SCIPmatrixGetRowValPtr, libscip), Ptr{Cdouble}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowIdxPtr(matrix, row) + ccall((:SCIPmatrixGetRowIdxPtr, libscip), Ptr{Cint}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowNNonzs(matrix, row) + ccall((:SCIPmatrixGetRowNNonzs, libscip), Cint, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowName(matrix, row) + ccall((:SCIPmatrixGetRowName, libscip), Cstring, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetNRows(matrix) + ccall((:SCIPmatrixGetNRows, libscip), Cint, (Ptr{SCIP_MATRIX},), matrix) +end + +function SCIPmatrixGetRowLhs(matrix, row) + ccall((:SCIPmatrixGetRowLhs, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowRhs(matrix, row) + ccall((:SCIPmatrixGetRowRhs, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixIsRowRhsInfinity(matrix, row) + ccall((:SCIPmatrixIsRowRhsInfinity, libscip), UInt32, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetNNonzs(matrix) + ccall((:SCIPmatrixGetNNonzs, libscip), Cint, (Ptr{SCIP_MATRIX},), matrix) +end + +function SCIPmatrixGetRowMinActivity(matrix, row) + ccall((:SCIPmatrixGetRowMinActivity, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowMaxActivity(matrix, row) + ccall((:SCIPmatrixGetRowMaxActivity, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowNMinActNegInf(matrix, row) + ccall((:SCIPmatrixGetRowNMinActNegInf, libscip), Cint, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowNMinActPosInf(matrix, row) + ccall((:SCIPmatrixGetRowNMinActPosInf, libscip), Cint, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowNMaxActNegInf(matrix, row) + ccall((:SCIPmatrixGetRowNMaxActNegInf, libscip), Cint, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowNMaxActPosInf(matrix, row) + ccall((:SCIPmatrixGetRowNMaxActPosInf, libscip), Cint, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetCons(matrix, row) + ccall((:SCIPmatrixGetCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixUplockConflict(matrix, col) + ccall((:SCIPmatrixUplockConflict, libscip), UInt32, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixDownlockConflict(matrix, col) + ccall((:SCIPmatrixDownlockConflict, libscip), UInt32, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixCreate(scip, matrixptr, initialized, complete) + ccall((:SCIPmatrixCreate, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{Ptr{SCIP_MATRIX}}, Ptr{UInt32}, Ptr{UInt32}), scip, matrixptr, initialized, complete) +end + +function SCIPmatrixFree(scip, matrix) + ccall((:SCIPmatrixFree, libscip), Cvoid, (Ptr{SCIP_}, Ptr{Ptr{SCIP_MATRIX}}), scip, matrix) +end + +function SCIPmatrixPrintRow(scip, matrix, row) + ccall((:SCIPmatrixPrintRow, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_MATRIX}, Cint), scip, matrix, row) +end + +function SCIPmatrixGetParallelRows(scip, matrix, scale, pclass) + ccall((:SCIPmatrixGetParallelRows, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_MATRIX}, Ptr{Cdouble}, Ptr{Cint}), scip, matrix, scale, pclass) +end + +function SCIPmatrixGetParallelCols(scip, matrix, scale, pclass, varineq) + ccall((:SCIPmatrixGetParallelCols, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_MATRIX}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}), scip, matrix, scale, pclass, varineq) +end diff --git a/src/wrapper/pub_message.jl b/src/wrapper/pub_message.jl new file mode 100644 index 00000000..af16a1dd --- /dev/null +++ b/src/wrapper/pub_message.jl @@ -0,0 +1,51 @@ +# Julia wrapper for header: /usr/include/scip/pub_message.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPmessagehdlrCreate(messagehdlr, bufferedoutput, filename, quiet, messagewarning, messagedialog, messageinfo, messagehdlrfree, messagehdlrdata) + ccall((:SCIPmessagehdlrCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_MESSAGEHDLR}}, UInt32, Cstring, UInt32, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_MESSAGEHDLRDATA}), messagehdlr, bufferedoutput, filename, quiet, messagewarning, messagedialog, messageinfo, messagehdlrfree, messagehdlrdata) +end + +function SCIPmessagehdlrCapture(messagehdlr) + ccall((:SCIPmessagehdlrCapture, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) +end + +function SCIPmessagehdlrRelease(messagehdlr) + ccall((:SCIPmessagehdlrRelease, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_MESSAGEHDLR}},), messagehdlr) +end + +function SCIPmessagehdlrSetData(messagehdlr, messagehdlrdata) + ccall((:SCIPmessagehdlrSetData, libscip), SCIP_RETCODE, (Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_MESSAGEHDLRDATA}), messagehdlr, messagehdlrdata) +end + +function SCIPmessagehdlrSetLogfile(messagehdlr, filename) + ccall((:SCIPmessagehdlrSetLogfile, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Cstring), messagehdlr, filename) +end + +function SCIPmessagehdlrSetQuiet(messagehdlr, quiet) + ccall((:SCIPmessagehdlrSetQuiet, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, UInt32), messagehdlr, quiet) +end + +function SCIPmessagePrintErrorHeader(sourcefile, sourceline) + ccall((:SCIPmessagePrintErrorHeader, libscip), Cvoid, (Cstring, Cint), sourcefile, sourceline) +end + +function SCIPmessageSetErrorPrinting(errorPrinting, data) + ccall((:SCIPmessageSetErrorPrinting, libscip), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}), errorPrinting, data) +end + +function SCIPmessageSetErrorPrintingDefault() + ccall((:SCIPmessageSetErrorPrintingDefault, libscip), Cvoid, ()) +end + +function SCIPmessagehdlrGetData(messagehdlr) + ccall((:SCIPmessagehdlrGetData, libscip), Ptr{SCIP_MESSAGEHDLRDATA}, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) +end + +function SCIPmessagehdlrGetLogfile(messagehdlr) + ccall((:SCIPmessagehdlrGetLogfile, libscip), Ptr{FILE}, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) +end + +function SCIPmessagehdlrIsQuiet(messagehdlr) + ccall((:SCIPmessagehdlrIsQuiet, libscip), UInt32, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) +end diff --git a/src/wrapper/pub_misc.jl b/src/wrapper/pub_misc.jl new file mode 100644 index 00000000..0717fbc0 --- /dev/null +++ b/src/wrapper/pub_misc.jl @@ -0,0 +1,851 @@ +# Julia wrapper for header: /usr/include/scip/pub_misc.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPstudentTGetCriticalValue(clevel, df) + ccall((:SCIPstudentTGetCriticalValue, libscip), Cdouble, (SCIP_CONFIDENCELEVEL, Cint), clevel, df) +end + +function SCIPcomputeTwoSampleTTestValue(meanx, meany, variancex, variancey, countx, county) + ccall((:SCIPcomputeTwoSampleTTestValue, libscip), Cdouble, (Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), meanx, meany, variancex, variancey, countx, county) +end + +function SCIPerf(x) + ccall((:SCIPerf, libscip), Cdouble, (Cdouble,), x) +end + +function SCIPnormalGetCriticalValue(clevel) + ccall((:SCIPnormalGetCriticalValue, libscip), Cdouble, (SCIP_CONFIDENCELEVEL,), clevel) +end + +function SCIPnormalCDF(mean, variance, value) + ccall((:SCIPnormalCDF, libscip), Cdouble, (Cdouble, Cdouble, Cdouble), mean, variance, value) +end + +function SCIPregressionGetNObservations(regression) + ccall((:SCIPregressionGetNObservations, libscip), Cint, (Ptr{SCIP_REGRESSION},), regression) +end + +function SCIPregressionGetSlope(regression) + ccall((:SCIPregressionGetSlope, libscip), Cdouble, (Ptr{SCIP_REGRESSION},), regression) +end + +function SCIPregressionGetIntercept(regression) + ccall((:SCIPregressionGetIntercept, libscip), Cdouble, (Ptr{SCIP_REGRESSION},), regression) +end + +function SCIPregressionRemoveObservation(regression, x, y) + ccall((:SCIPregressionRemoveObservation, libscip), Cvoid, (Ptr{SCIP_REGRESSION}, Cdouble, Cdouble), regression, x, y) +end + +function SCIPregressionAddObservation(regression, x, y) + ccall((:SCIPregressionAddObservation, libscip), Cvoid, (Ptr{SCIP_REGRESSION}, Cdouble, Cdouble), regression, x, y) +end + +function SCIPregressionReset(regression) + ccall((:SCIPregressionReset, libscip), Cvoid, (Ptr{SCIP_REGRESSION},), regression) +end + +function SCIPregressionCreate(regression) + ccall((:SCIPregressionCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_REGRESSION}},), regression) +end + +function SCIPregressionFree(regression) + ccall((:SCIPregressionFree, libscip), Cvoid, (Ptr{Ptr{SCIP_REGRESSION}},), regression) +end + +function SCIPgmlWriteNode(file, id, label, nodetype, fillcolor, bordercolor) + ccall((:SCIPgmlWriteNode, libscip), Cvoid, (Ptr{FILE}, UInt32, Cstring, Cstring, Cstring, Cstring), file, id, label, nodetype, fillcolor, bordercolor) +end + +function SCIPgmlWriteNodeWeight(file, id, label, nodetype, fillcolor, bordercolor, weight) + ccall((:SCIPgmlWriteNodeWeight, libscip), Cvoid, (Ptr{FILE}, UInt32, Cstring, Cstring, Cstring, Cstring, Cdouble), file, id, label, nodetype, fillcolor, bordercolor, weight) +end + +function SCIPgmlWriteEdge(file, source, target, label, color) + ccall((:SCIPgmlWriteEdge, libscip), Cvoid, (Ptr{FILE}, UInt32, UInt32, Cstring, Cstring), file, source, target, label, color) +end + +function SCIPgmlWriteArc(file, source, target, label, color) + ccall((:SCIPgmlWriteArc, libscip), Cvoid, (Ptr{FILE}, UInt32, UInt32, Cstring, Cstring), file, source, target, label, color) +end + +function SCIPgmlWriteOpening(file, directed) + ccall((:SCIPgmlWriteOpening, libscip), Cvoid, (Ptr{FILE}, UInt32), file, directed) +end + +function SCIPgmlWriteClosing(file) + ccall((:SCIPgmlWriteClosing, libscip), Cvoid, (Ptr{FILE},), file) +end + +function SCIPsparseSolCreate(sparsesol, vars, nvars, cleared) + ccall((:SCIPsparseSolCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SPARSESOL}}, Ptr{Ptr{SCIP_VAR}}, Cint, UInt32), sparsesol, vars, nvars, cleared) +end + +function SCIPsparseSolFree(sparsesol) + ccall((:SCIPsparseSolFree, libscip), Cvoid, (Ptr{Ptr{SCIP_SPARSESOL}},), sparsesol) +end + +function SCIPsparseSolGetVars(sparsesol) + ccall((:SCIPsparseSolGetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_SPARSESOL},), sparsesol) +end + +function SCIPsparseSolGetNVars(sparsesol) + ccall((:SCIPsparseSolGetNVars, libscip), Cint, (Ptr{SCIP_SPARSESOL},), sparsesol) +end + +function SCIPsparseSolGetLbs(sparsesol) + ccall((:SCIPsparseSolGetLbs, libscip), Ptr{Clonglong}, (Ptr{SCIP_SPARSESOL},), sparsesol) +end + +function SCIPsparseSolGetUbs(sparsesol) + ccall((:SCIPsparseSolGetUbs, libscip), Ptr{Clonglong}, (Ptr{SCIP_SPARSESOL},), sparsesol) +end + +function SCIPsparseSolGetFirstSol(sparsesol, sol, nvars) + ccall((:SCIPsparseSolGetFirstSol, libscip), Cvoid, (Ptr{SCIP_SPARSESOL}, Ptr{Clonglong}, Cint), sparsesol, sol, nvars) +end + +function SCIPsparseSolGetNextSol(sparsesol, sol, nvars) + ccall((:SCIPsparseSolGetNextSol, libscip), UInt32, (Ptr{SCIP_SPARSESOL}, Ptr{Clonglong}, Cint), sparsesol, sol, nvars) +end + +function SCIPqueueCreate(queue, initsize, sizefac) + ccall((:SCIPqueueCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_QUEUE}}, Cint, Cdouble), queue, initsize, sizefac) +end + +function SCIPqueueFree(queue) + ccall((:SCIPqueueFree, libscip), Cvoid, (Ptr{Ptr{SCIP_QUEUE}},), queue) +end + +function SCIPqueueClear(queue) + ccall((:SCIPqueueClear, libscip), Cvoid, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueInsert(queue, elem) + ccall((:SCIPqueueInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_QUEUE}, Ptr{Cvoid}), queue, elem) +end + +function SCIPqueueRemove(queue) + ccall((:SCIPqueueRemove, libscip), Ptr{Cvoid}, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueFirst(queue) + ccall((:SCIPqueueFirst, libscip), Ptr{Cvoid}, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueIsEmpty(queue) + ccall((:SCIPqueueIsEmpty, libscip), UInt32, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueNElems(queue) + ccall((:SCIPqueueNElems, libscip), Cint, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPpqueueCreate(pqueue, initsize, sizefac, ptrcomp) + ccall((:SCIPpqueueCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_PQUEUE}}, Cint, Cdouble, Ptr{Cvoid}), pqueue, initsize, sizefac, ptrcomp) +end + +function SCIPpqueueFree(pqueue) + ccall((:SCIPpqueueFree, libscip), Cvoid, (Ptr{Ptr{SCIP_PQUEUE}},), pqueue) +end + +function SCIPpqueueClear(pqueue) + ccall((:SCIPpqueueClear, libscip), Cvoid, (Ptr{SCIP_PQUEUE},), pqueue) +end + +function SCIPpqueueInsert(pqueue, elem) + ccall((:SCIPpqueueInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_PQUEUE}, Ptr{Cvoid}), pqueue, elem) +end + +function SCIPpqueueRemove(pqueue) + ccall((:SCIPpqueueRemove, libscip), Ptr{Cvoid}, (Ptr{SCIP_PQUEUE},), pqueue) +end + +function SCIPpqueueFirst(pqueue) + ccall((:SCIPpqueueFirst, libscip), Ptr{Cvoid}, (Ptr{SCIP_PQUEUE},), pqueue) +end + +function SCIPpqueueNElems(pqueue) + ccall((:SCIPpqueueNElems, libscip), Cint, (Ptr{SCIP_PQUEUE},), pqueue) +end + +function SCIPpqueueElems(pqueue) + ccall((:SCIPpqueueElems, libscip), Ptr{Ptr{Cvoid}}, (Ptr{SCIP_PQUEUE},), pqueue) +end + +function SCIPrealHashCode(x) + ccall((:SCIPrealHashCode, libscip), UInt32, (Cdouble,), x) +end + +function SCIPhashtableCreate(hashtable, blkmem, tablesize, hashgetkey, hashkeyeq, hashkeyval, userptr) + ccall((:SCIPhashtableCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_HASHTABLE}}, Ptr{BMS_BLKMEM}, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), hashtable, blkmem, tablesize, hashgetkey, hashkeyeq, hashkeyval, userptr) +end + +function SCIPhashtableFree(hashtable) + ccall((:SCIPhashtableFree, libscip), Cvoid, (Ptr{Ptr{SCIP_HASHTABLE}},), hashtable) +end + +function SCIPhashtableClear(hashtable) + ccall((:SCIPhashtableClear, libscip), Cvoid, (Ptr{SCIP_HASHTABLE},), hashtable) +end + +function SCIPhashtableInsert(hashtable, element) + ccall((:SCIPhashtableInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), hashtable, element) +end + +function SCIPhashtableSafeInsert(hashtable, element) + ccall((:SCIPhashtableSafeInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), hashtable, element) +end + +function SCIPhashtableRetrieve(hashtable, key) + ccall((:SCIPhashtableRetrieve, libscip), Ptr{Cvoid}, (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), hashtable, key) +end + +function SCIPhashtableExists(hashtable, element) + ccall((:SCIPhashtableExists, libscip), UInt32, (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), hashtable, element) +end + +function SCIPhashtableRemove(hashtable, element) + ccall((:SCIPhashtableRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), hashtable, element) +end + +function SCIPhashtableRemoveAll(hashtable) + ccall((:SCIPhashtableRemoveAll, libscip), Cvoid, (Ptr{SCIP_HASHTABLE},), hashtable) +end + +function SCIPhashtableGetNElements(hashtable) + ccall((:SCIPhashtableGetNElements, libscip), Clonglong, (Ptr{SCIP_HASHTABLE},), hashtable) +end + +function SCIPhashtableGetNEntries(hashtable) + ccall((:SCIPhashtableGetNEntries, libscip), Cint, (Ptr{SCIP_HASHTABLE},), hashtable) +end + +function SCIPhashtableGetEntry(hashtable, entryidx) + ccall((:SCIPhashtableGetEntry, libscip), Ptr{Cvoid}, (Ptr{SCIP_HASHTABLE}, Cint), hashtable, entryidx) +end + +function SCIPhashtableGetLoad(hashtable) + ccall((:SCIPhashtableGetLoad, libscip), Cdouble, (Ptr{SCIP_HASHTABLE},), hashtable) +end + +function SCIPhashtablePrintStatistics(hashtable, messagehdlr) + ccall((:SCIPhashtablePrintStatistics, libscip), Cvoid, (Ptr{SCIP_HASHTABLE}, Ptr{SCIP_MESSAGEHDLR}), hashtable, messagehdlr) +end + +function SCIPcalcMultihashSize(minsize) + ccall((:SCIPcalcMultihashSize, libscip), Cint, (Cint,), minsize) +end + +function SCIPmultihashCreate(multihash, blkmem, tablesize, hashgetkey, hashkeyeq, hashkeyval, userptr) + ccall((:SCIPmultihashCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_MULTIHASH}}, Ptr{BMS_BLKMEM}, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), multihash, blkmem, tablesize, hashgetkey, hashkeyeq, hashkeyval, userptr) +end + +function SCIPmultihashFree(multihash) + ccall((:SCIPmultihashFree, libscip), Cvoid, (Ptr{Ptr{SCIP_MULTIHASH}},), multihash) +end + +function SCIPmultihashInsert(multihash, element) + ccall((:SCIPmultihashInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), multihash, element) +end + +function SCIPmultihashSafeInsert(multihash, element) + ccall((:SCIPmultihashSafeInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), multihash, element) +end + +function SCIPmultihashRetrieve(multihash, key) + ccall((:SCIPmultihashRetrieve, libscip), Ptr{Cvoid}, (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), multihash, key) +end + +function SCIPmultihashRetrieveNext(multihash, multihashlist, key) + ccall((:SCIPmultihashRetrieveNext, libscip), Ptr{Cvoid}, (Ptr{SCIP_MULTIHASH}, Ptr{Ptr{SCIP_MULTIHASHLIST}}, Ptr{Cvoid}), multihash, multihashlist, key) +end + +function SCIPmultihashExists(multihash, element) + ccall((:SCIPmultihashExists, libscip), UInt32, (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), multihash, element) +end + +function SCIPmultihashRemove(multihash, element) + ccall((:SCIPmultihashRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), multihash, element) +end + +function SCIPmultihashRemoveAll(multihash) + ccall((:SCIPmultihashRemoveAll, libscip), Cvoid, (Ptr{SCIP_MULTIHASH},), multihash) +end + +function SCIPmultihashGetNElements(multihash) + ccall((:SCIPmultihashGetNElements, libscip), Clonglong, (Ptr{SCIP_MULTIHASH},), multihash) +end + +function SCIPmultihashGetLoad(multihash) + ccall((:SCIPmultihashGetLoad, libscip), Cdouble, (Ptr{SCIP_MULTIHASH},), multihash) +end + +function SCIPmultihashPrintStatistics(multihash, messagehdlr) + ccall((:SCIPmultihashPrintStatistics, libscip), Cvoid, (Ptr{SCIP_MULTIHASH}, Ptr{SCIP_MESSAGEHDLR}), multihash, messagehdlr) +end + +function SCIPhashKeyEqString(userptr, key1, key2) + ccall((:SCIPhashKeyEqString, libscip), UInt32, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), userptr, key1, key2) +end + +function SCIPhashKeyValString(userptr, key) + ccall((:SCIPhashKeyValString, libscip), UInt64, (Ptr{Cvoid}, Ptr{Cvoid}), userptr, key) +end + +function SCIPhashGetKeyStandard(userptr, elem) + ccall((:SCIPhashGetKeyStandard, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Ptr{Cvoid}), userptr, elem) +end + +function SCIPhashKeyEqPtr(userptr, key1, key2) + ccall((:SCIPhashKeyEqPtr, libscip), UInt32, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), userptr, key1, key2) +end + +function SCIPhashKeyValPtr(userptr, key) + ccall((:SCIPhashKeyValPtr, libscip), UInt64, (Ptr{Cvoid}, Ptr{Cvoid}), userptr, key) +end + +function SCIPhashmapCreate(hashmap, blkmem, mapsize) + ccall((:SCIPhashmapCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_HASHMAP}}, Ptr{BMS_BLKMEM}, Cint), hashmap, blkmem, mapsize) +end + +function SCIPhashmapFree(hashmap) + ccall((:SCIPhashmapFree, libscip), Cvoid, (Ptr{Ptr{SCIP_HASHMAP}},), hashmap) +end + +function SCIPhashmapInsert(hashmap, origin, image) + ccall((:SCIPhashmapInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Ptr{Cvoid}), hashmap, origin, image) +end + +function SCIPhashmapInsertReal(hashmap, origin, image) + ccall((:SCIPhashmapInsertReal, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cdouble), hashmap, origin, image) +end + +function SCIPhashmapGetImage(hashmap, origin) + ccall((:SCIPhashmapGetImage, libscip), Ptr{Cvoid}, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), hashmap, origin) +end + +function SCIPhashmapGetImageReal(hashmap, origin) + ccall((:SCIPhashmapGetImageReal, libscip), Cdouble, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), hashmap, origin) +end + +function SCIPhashmapSetImage(hashmap, origin, image) + ccall((:SCIPhashmapSetImage, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Ptr{Cvoid}), hashmap, origin, image) +end + +function SCIPhashmapSetImageReal(hashmap, origin, image) + ccall((:SCIPhashmapSetImageReal, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cdouble), hashmap, origin, image) +end + +function SCIPhashmapExists(hashmap, origin) + ccall((:SCIPhashmapExists, libscip), UInt32, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), hashmap, origin) +end + +function SCIPhashmapRemove(hashmap, origin) + ccall((:SCIPhashmapRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), hashmap, origin) +end + +function SCIPhashmapPrintStatistics(hashmap, messagehdlr) + ccall((:SCIPhashmapPrintStatistics, libscip), Cvoid, (Ptr{SCIP_HASHMAP}, Ptr{SCIP_MESSAGEHDLR}), hashmap, messagehdlr) +end + +function SCIPhashmapIsEmpty(hashmap) + ccall((:SCIPhashmapIsEmpty, libscip), UInt32, (Ptr{SCIP_HASHMAP},), hashmap) +end + +function SCIPhashmapGetNElements(hashmap) + ccall((:SCIPhashmapGetNElements, libscip), Cint, (Ptr{SCIP_HASHMAP},), hashmap) +end + +function SCIPhashmapGetNEntries(hashmap) + ccall((:SCIPhashmapGetNEntries, libscip), Cint, (Ptr{SCIP_HASHMAP},), hashmap) +end + +function SCIPhashmapGetEntry(hashmap, entryidx) + ccall((:SCIPhashmapGetEntry, libscip), Ptr{SCIP_HASHMAPENTRY}, (Ptr{SCIP_HASHMAP}, Cint), hashmap, entryidx) +end + +function SCIPhashmapEntryGetOrigin(entry) + ccall((:SCIPhashmapEntryGetOrigin, libscip), Ptr{Cvoid}, (Ptr{SCIP_HASHMAPENTRY},), entry) +end + +function SCIPhashmapEntryGetImage(entry) + ccall((:SCIPhashmapEntryGetImage, libscip), Ptr{Cvoid}, (Ptr{SCIP_HASHMAPENTRY},), entry) +end + +function SCIPhashmapEntryGetImageReal(entry) + ccall((:SCIPhashmapEntryGetImageReal, libscip), Cdouble, (Ptr{SCIP_HASHMAPENTRY},), entry) +end + +function SCIPhashmapEntrySetImage(entry, image) + ccall((:SCIPhashmapEntrySetImage, libscip), Cvoid, (Ptr{SCIP_HASHMAPENTRY}, Ptr{Cvoid}), entry, image) +end + +function SCIPhashmapEntrySetImageReal(entry, image) + ccall((:SCIPhashmapEntrySetImageReal, libscip), Cvoid, (Ptr{SCIP_HASHMAPENTRY}, Cdouble), entry, image) +end + +function SCIPhashmapRemoveAll(hashmap) + ccall((:SCIPhashmapRemoveAll, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP},), hashmap) +end + +function SCIPhashsetCreate(hashset, blkmem, size) + ccall((:SCIPhashsetCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_HASHSET}}, Ptr{BMS_BLKMEM}, Cint), hashset, blkmem, size) +end + +function SCIPhashsetFree(hashset, blkmem) + ccall((:SCIPhashsetFree, libscip), Cvoid, (Ptr{Ptr{SCIP_HASHSET}}, Ptr{BMS_BLKMEM}), hashset, blkmem) +end + +function SCIPhashsetInsert(hashset, blkmem, element) + ccall((:SCIPhashsetInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHSET}, Ptr{BMS_BLKMEM}, Ptr{Cvoid}), hashset, blkmem, element) +end + +function SCIPhashsetExists(hashset, element) + ccall((:SCIPhashsetExists, libscip), UInt32, (Ptr{SCIP_HASHSET}, Ptr{Cvoid}), hashset, element) +end + +function SCIPhashsetRemove(hashset, element) + ccall((:SCIPhashsetRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHSET}, Ptr{Cvoid}), hashset, element) +end + +function SCIPhashsetPrintStatistics(hashset, messagehdlr) + ccall((:SCIPhashsetPrintStatistics, libscip), Cvoid, (Ptr{SCIP_HASHSET}, Ptr{SCIP_MESSAGEHDLR}), hashset, messagehdlr) +end + +function SCIPhashsetIsEmpty(hashset) + ccall((:SCIPhashsetIsEmpty, libscip), UInt32, (Ptr{SCIP_HASHSET},), hashset) +end + +function SCIPhashsetGetNElements(hashset) + ccall((:SCIPhashsetGetNElements, libscip), Cint, (Ptr{SCIP_HASHSET},), hashset) +end + +function SCIPhashsetGetNSlots(hashset) + ccall((:SCIPhashsetGetNSlots, libscip), Cint, (Ptr{SCIP_HASHSET},), hashset) +end + +function SCIPhashsetGetSlots(hashset) + ccall((:SCIPhashsetGetSlots, libscip), Ptr{Ptr{Cvoid}}, (Ptr{SCIP_HASHSET},), hashset) +end + +function SCIPhashsetRemoveAll(hashset) + ccall((:SCIPhashsetRemoveAll, libscip), Cvoid, (Ptr{SCIP_HASHSET},), hashset) +end + +function SCIPactivityCreate(activity, var, duration, demand) + ccall((:SCIPactivityCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RESOURCEACTIVITY}}, Ptr{SCIP_VAR}, Cint, Cint), activity, var, duration, demand) +end + +function SCIPactivityFree(activity) + ccall((:SCIPactivityFree, libscip), Cvoid, (Ptr{Ptr{SCIP_RESOURCEACTIVITY}},), activity) +end + +function SCIPactivityGetVar(activity) + ccall((:SCIPactivityGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_RESOURCEACTIVITY},), activity) +end + +function SCIPactivityGetDuration(activity) + ccall((:SCIPactivityGetDuration, libscip), Cint, (Ptr{SCIP_RESOURCEACTIVITY},), activity) +end + +function SCIPactivityGetDemand(activity) + ccall((:SCIPactivityGetDemand, libscip), Cint, (Ptr{SCIP_RESOURCEACTIVITY},), activity) +end + +function SCIPactivityGetEnergy(activity) + ccall((:SCIPactivityGetEnergy, libscip), Cint, (Ptr{SCIP_RESOURCEACTIVITY},), activity) +end + +function SCIPprofileCreate(profile, capacity) + ccall((:SCIPprofileCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_PROFILE}}, Cint), profile, capacity) +end + +function SCIPprofileFree(profile) + ccall((:SCIPprofileFree, libscip), Cvoid, (Ptr{Ptr{SCIP_PROFILE}},), profile) +end + +function SCIPprofilePrint(profile, messagehdlr, file) + ccall((:SCIPprofilePrint, libscip), Cvoid, (Ptr{SCIP_PROFILE}, Ptr{SCIP_MESSAGEHDLR}, Ptr{FILE}), profile, messagehdlr, file) +end + +function SCIPprofileGetCapacity(profile) + ccall((:SCIPprofileGetCapacity, libscip), Cint, (Ptr{SCIP_PROFILE},), profile) +end + +function SCIPprofileGetNTimepoints(profile) + ccall((:SCIPprofileGetNTimepoints, libscip), Cint, (Ptr{SCIP_PROFILE},), profile) +end + +function SCIPprofileGetTimepoints(profile) + ccall((:SCIPprofileGetTimepoints, libscip), Ptr{Cint}, (Ptr{SCIP_PROFILE},), profile) +end + +function SCIPprofileGetLoads(profile) + ccall((:SCIPprofileGetLoads, libscip), Ptr{Cint}, (Ptr{SCIP_PROFILE},), profile) +end + +function SCIPprofileGetTime(profile, pos) + ccall((:SCIPprofileGetTime, libscip), Cint, (Ptr{SCIP_PROFILE}, Cint), profile, pos) +end + +function SCIPprofileGetLoad(profile, pos) + ccall((:SCIPprofileGetLoad, libscip), Cint, (Ptr{SCIP_PROFILE}, Cint), profile, pos) +end + +function SCIPprofileFindLeft(profile, timepoint, pos) + ccall((:SCIPprofileFindLeft, libscip), UInt32, (Ptr{SCIP_PROFILE}, Cint, Ptr{Cint}), profile, timepoint, pos) +end + +function SCIPprofileInsertCore(profile, left, right, height, pos, infeasible) + ccall((:SCIPprofileInsertCore, libscip), SCIP_RETCODE, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Ptr{Cint}, Ptr{UInt32}), profile, left, right, height, pos, infeasible) +end + +function SCIPprofileDeleteCore(profile, left, right, height) + ccall((:SCIPprofileDeleteCore, libscip), SCIP_RETCODE, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint), profile, left, right, height) +end + +function SCIPprofileGetEarliestFeasibleStart(profile, est, lst, duration, height, infeasible) + ccall((:SCIPprofileGetEarliestFeasibleStart, libscip), Cint, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Cint, Ptr{UInt32}), profile, est, lst, duration, height, infeasible) +end + +function SCIPprofileGetLatestFeasibleStart(profile, lb, ub, duration, height, infeasible) + ccall((:SCIPprofileGetLatestFeasibleStart, libscip), Cint, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Cint, Ptr{UInt32}), profile, lb, ub, duration, height, infeasible) +end + +function SCIPdigraphResize(digraph, nnodes) + ccall((:SCIPdigraphResize, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Cint), digraph, nnodes) +end + +function SCIPdigraphSetSizes(digraph, sizes) + ccall((:SCIPdigraphSetSizes, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Ptr{Cint}), digraph, sizes) +end + +function SCIPdigraphFree(digraph) + ccall((:SCIPdigraphFree, libscip), Cvoid, (Ptr{Ptr{SCIP_DIGRAPH}},), digraph) +end + +function SCIPdigraphAddArc(digraph, startnode, endnode, data) + ccall((:SCIPdigraphAddArc, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Cint, Cint, Ptr{Cvoid}), digraph, startnode, endnode, data) +end + +function SCIPdigraphAddArcSafe(digraph, startnode, endnode, data) + ccall((:SCIPdigraphAddArcSafe, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Cint, Cint, Ptr{Cvoid}), digraph, startnode, endnode, data) +end + +function SCIPdigraphSetNSuccessors(digraph, node, nsuccessors) + ccall((:SCIPdigraphSetNSuccessors, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Cint, Cint), digraph, node, nsuccessors) +end + +function SCIPdigraphGetNNodes(digraph) + ccall((:SCIPdigraphGetNNodes, libscip), Cint, (Ptr{SCIP_DIGRAPH},), digraph) +end + +function SCIPdigraphGetNodeData(digraph, node) + ccall((:SCIPdigraphGetNodeData, libscip), Ptr{Cvoid}, (Ptr{SCIP_DIGRAPH}, Cint), digraph, node) +end + +function SCIPdigraphSetNodeData(digraph, dataptr, node) + ccall((:SCIPdigraphSetNodeData, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Ptr{Cvoid}, Cint), digraph, dataptr, node) +end + +function SCIPdigraphGetNArcs(digraph) + ccall((:SCIPdigraphGetNArcs, libscip), Cint, (Ptr{SCIP_DIGRAPH},), digraph) +end + +function SCIPdigraphGetNSuccessors(digraph, node) + ccall((:SCIPdigraphGetNSuccessors, libscip), Cint, (Ptr{SCIP_DIGRAPH}, Cint), digraph, node) +end + +function SCIPdigraphGetSuccessors(digraph, node) + ccall((:SCIPdigraphGetSuccessors, libscip), Ptr{Cint}, (Ptr{SCIP_DIGRAPH}, Cint), digraph, node) +end + +function SCIPdigraphGetSuccessorsData(digraph, node) + ccall((:SCIPdigraphGetSuccessorsData, libscip), Ptr{Ptr{Cvoid}}, (Ptr{SCIP_DIGRAPH}, Cint), digraph, node) +end + +function SCIPdigraphComputeUndirectedComponents(digraph, minsize, components, ncomponents) + ccall((:SCIPdigraphComputeUndirectedComponents, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Cint, Ptr{Cint}, Ptr{Cint}), digraph, minsize, components, ncomponents) +end + +function SCIPdigraphComputeDirectedComponents(digraph, compidx, strongcomponents, strongcompstartidx, nstrongcomponents) + ccall((:SCIPdigraphComputeDirectedComponents, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), digraph, compidx, strongcomponents, strongcompstartidx, nstrongcomponents) +end + +function SCIPdigraphTopoSortComponents(digraph) + ccall((:SCIPdigraphTopoSortComponents, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH},), digraph) +end + +function SCIPdigraphGetNComponents(digraph) + ccall((:SCIPdigraphGetNComponents, libscip), Cint, (Ptr{SCIP_DIGRAPH},), digraph) +end + +function SCIPdigraphGetComponent(digraph, compidx, nodes, nnodes) + ccall((:SCIPdigraphGetComponent, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Cint, Ptr{Ptr{Cint}}, Ptr{Cint}), digraph, compidx, nodes, nnodes) +end + +function SCIPdigraphFreeComponents(digraph) + ccall((:SCIPdigraphFreeComponents, libscip), Cvoid, (Ptr{SCIP_DIGRAPH},), digraph) +end + +function SCIPdigraphPrint(digraph, messagehdlr, file) + ccall((:SCIPdigraphPrint, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Ptr{SCIP_MESSAGEHDLR}, Ptr{FILE}), digraph, messagehdlr, file) +end + +function SCIPdigraphPrintGml(digraph, file) + ccall((:SCIPdigraphPrintGml, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Ptr{FILE}), digraph, file) +end + +function SCIPdigraphPrintComponents(digraph, messagehdlr, file) + ccall((:SCIPdigraphPrintComponents, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Ptr{SCIP_MESSAGEHDLR}, Ptr{FILE}), digraph, messagehdlr, file) +end + +function SCIPbtnodeCreate(tree, node, dataptr) + ccall((:SCIPbtnodeCreate, libscip), SCIP_RETCODE, (Ptr{SCIP_BT}, Ptr{Ptr{SCIP_BTNODE}}, Ptr{Cvoid}), tree, node, dataptr) +end + +function SCIPbtnodeFree(tree, node) + ccall((:SCIPbtnodeFree, libscip), Cvoid, (Ptr{SCIP_BT}, Ptr{Ptr{SCIP_BTNODE}}), tree, node) +end + +function SCIPbtnodeGetData(node) + ccall((:SCIPbtnodeGetData, libscip), Ptr{Cvoid}, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeGetParent(node) + ccall((:SCIPbtnodeGetParent, libscip), Ptr{SCIP_BTNODE}, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeGetLeftchild(node) + ccall((:SCIPbtnodeGetLeftchild, libscip), Ptr{SCIP_BTNODE}, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeGetRightchild(node) + ccall((:SCIPbtnodeGetRightchild, libscip), Ptr{SCIP_BTNODE}, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeGetSibling(node) + ccall((:SCIPbtnodeGetSibling, libscip), Ptr{SCIP_BTNODE}, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeIsRoot(node) + ccall((:SCIPbtnodeIsRoot, libscip), UInt32, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeIsLeaf(node) + ccall((:SCIPbtnodeIsLeaf, libscip), UInt32, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeIsLeftchild(node) + ccall((:SCIPbtnodeIsLeftchild, libscip), UInt32, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeIsRightchild(node) + ccall((:SCIPbtnodeIsRightchild, libscip), UInt32, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeSetData(node, dataptr) + ccall((:SCIPbtnodeSetData, libscip), Cvoid, (Ptr{SCIP_BTNODE}, Ptr{Cvoid}), node, dataptr) +end + +function SCIPbtnodeSetParent(node, parent) + ccall((:SCIPbtnodeSetParent, libscip), Cvoid, (Ptr{SCIP_BTNODE}, Ptr{SCIP_BTNODE}), node, parent) +end + +function SCIPbtnodeSetLeftchild(node, left) + ccall((:SCIPbtnodeSetLeftchild, libscip), Cvoid, (Ptr{SCIP_BTNODE}, Ptr{SCIP_BTNODE}), node, left) +end + +function SCIPbtnodeSetRightchild(node, right) + ccall((:SCIPbtnodeSetRightchild, libscip), Cvoid, (Ptr{SCIP_BTNODE}, Ptr{SCIP_BTNODE}), node, right) +end + +function SCIPbtCreate(tree, blkmem) + ccall((:SCIPbtCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_BT}}, Ptr{BMS_BLKMEM}), tree, blkmem) +end + +function SCIPbtFree(tree) + ccall((:SCIPbtFree, libscip), Cvoid, (Ptr{Ptr{SCIP_BT}},), tree) +end + +function SCIPbtPrintGml(tree, file) + ccall((:SCIPbtPrintGml, libscip), Cvoid, (Ptr{SCIP_BT}, Ptr{FILE}), tree, file) +end + +function SCIPbtIsEmpty(tree) + ccall((:SCIPbtIsEmpty, libscip), UInt32, (Ptr{SCIP_BT},), tree) +end + +function SCIPbtGetRoot(tree) + ccall((:SCIPbtGetRoot, libscip), Ptr{SCIP_BTNODE}, (Ptr{SCIP_BT},), tree) +end + +function SCIPbtSetRoot(tree, root) + ccall((:SCIPbtSetRoot, libscip), Cvoid, (Ptr{SCIP_BT}, Ptr{SCIP_BTNODE}), tree, root) +end + +function SCIPdisjointsetClear(djset) + ccall((:SCIPdisjointsetClear, libscip), Cvoid, (Ptr{SCIP_DISJOINTSET},), djset) +end + +function SCIPdisjointsetFind(djset, element) + ccall((:SCIPdisjointsetFind, libscip), Cint, (Ptr{SCIP_DISJOINTSET}, Cint), djset, element) +end + +function SCIPdisjointsetUnion(djset, p, q, forcerepofp) + ccall((:SCIPdisjointsetUnion, libscip), Cvoid, (Ptr{SCIP_DISJOINTSET}, Cint, Cint, UInt32), djset, p, q, forcerepofp) +end + +function SCIPdisjointsetGetComponentCount(djset) + ccall((:SCIPdisjointsetGetComponentCount, libscip), Cint, (Ptr{SCIP_DISJOINTSET},), djset) +end + +function SCIPdisjointsetGetSize(djset) + ccall((:SCIPdisjointsetGetSize, libscip), Cint, (Ptr{SCIP_DISJOINTSET},), djset) +end + +function SCIPcalcMachineEpsilon() + ccall((:SCIPcalcMachineEpsilon, libscip), Cdouble, ()) +end + +function SCIPnextafter(from, to) + ccall((:SCIPnextafter, libscip), Cdouble, (Cdouble, Cdouble), from, to) +end + +function SCIPcalcGreComDiv(val1, val2) + ccall((:SCIPcalcGreComDiv, libscip), Clonglong, (Clonglong, Clonglong), val1, val2) +end + +function SCIPcalcSmaComMul(val1, val2) + ccall((:SCIPcalcSmaComMul, libscip), Clonglong, (Clonglong, Clonglong), val1, val2) +end + +function SCIPcalcBinomCoef(n, m) + ccall((:SCIPcalcBinomCoef, libscip), Clonglong, (Cint, Cint), n, m) +end + +function SCIPrealToRational(val, mindelta, maxdelta, maxdnom, nominator, denominator) + ccall((:SCIPrealToRational, libscip), UInt32, (Cdouble, Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), val, mindelta, maxdelta, maxdnom, nominator, denominator) +end + +function SCIPcalcIntegralScalar(vals, nvals, mindelta, maxdelta, maxdnom, maxscale, intscalar, success) + ccall((:SCIPcalcIntegralScalar, libscip), SCIP_RETCODE, (Ptr{Cdouble}, Cint, Cdouble, Cdouble, Clonglong, Cdouble, Ptr{Cdouble}, Ptr{UInt32}), vals, nvals, mindelta, maxdelta, maxdnom, maxscale, intscalar, success) +end + +function SCIPfindSimpleRational(lb, ub, maxdnom, nominator, denominator) + ccall((:SCIPfindSimpleRational, libscip), UInt32, (Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), lb, ub, maxdnom, nominator, denominator) +end + +function SCIPselectSimpleValue(lb, ub, maxdnom) + ccall((:SCIPselectSimpleValue, libscip), Cdouble, (Cdouble, Cdouble, Clonglong), lb, ub, maxdnom) +end + +function SCIPrelDiff(val1, val2) + ccall((:SCIPrelDiff, libscip), Cdouble, (Cdouble, Cdouble), val1, val2) +end + +function SCIPcomputeGap(eps, inf, primalbound, dualbound) + ccall((:SCIPcomputeGap, libscip), Cdouble, (Cdouble, Cdouble, Cdouble, Cdouble), eps, inf, primalbound, dualbound) +end + +function SCIPgetRandomInt(minrandval, maxrandval, seedp) + ccall((:SCIPgetRandomInt, libscip), Cint, (Cint, Cint, Ptr{UInt32}), minrandval, maxrandval, seedp) +end + +function SCIPrandomGetInt(randgen, minrandval, maxrandval) + ccall((:SCIPrandomGetInt, libscip), Cint, (Ptr{SCIP_RANDNUMGEN}, Cint, Cint), randgen, minrandval, maxrandval) +end + +function SCIPrandomGetSubset(randgen, set, nelems, subset, nsubelems) + ccall((:SCIPrandomGetSubset, libscip), SCIP_RETCODE, (Ptr{SCIP_RANDNUMGEN}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Ptr{Cvoid}}, Cint), randgen, set, nelems, subset, nsubelems) +end + +function SCIPrandomGetReal(randgen, minrandval, maxrandval) + ccall((:SCIPrandomGetReal, libscip), Cdouble, (Ptr{SCIP_RANDNUMGEN}, Cdouble, Cdouble), randgen, minrandval, maxrandval) +end + +function SCIPgetRandomReal(minrandval, maxrandval, seedp) + ccall((:SCIPgetRandomReal, libscip), Cdouble, (Cdouble, Cdouble, Ptr{UInt32}), minrandval, maxrandval, seedp) +end + +function SCIPgetRandomSubset(set, nelems, subset, nsubelems, randseed) + ccall((:SCIPgetRandomSubset, libscip), SCIP_RETCODE, (Ptr{Ptr{Cvoid}}, Cint, Ptr{Ptr{Cvoid}}, Cint, UInt32), set, nelems, subset, nsubelems, randseed) +end + +function SCIPswapInts(value1, value2) + ccall((:SCIPswapInts, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}), value1, value2) +end + +function SCIPswapReals(value1, value2) + ccall((:SCIPswapReals, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}), value1, value2) +end + +function SCIPswapPointers(pointer1, pointer2) + ccall((:SCIPswapPointers, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}), pointer1, pointer2) +end + +function SCIPpermuteIntArray(array, _begin, _end, randseed) + ccall((:SCIPpermuteIntArray, libscip), Cvoid, (Ptr{Cint}, Cint, Cint, Ptr{UInt32}), array, _begin, _end, randseed) +end + +function SCIPrandomPermuteIntArray(randgen, array, _begin, _end) + ccall((:SCIPrandomPermuteIntArray, libscip), Cvoid, (Ptr{SCIP_RANDNUMGEN}, Ptr{Cint}, Cint, Cint), randgen, array, _begin, _end) +end + +function SCIPrandomPermuteArray(randgen, array, _begin, _end) + ccall((:SCIPrandomPermuteArray, libscip), Cvoid, (Ptr{SCIP_RANDNUMGEN}, Ptr{Ptr{Cvoid}}, Cint, Cint), randgen, array, _begin, _end) +end + +function SCIPpermuteArray(array, _begin, _end, randseed) + ccall((:SCIPpermuteArray, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Cint, Cint, Ptr{UInt32}), array, _begin, _end, randseed) +end + +function SCIPcomputeArraysIntersection(array1, narray1, array2, narray2, intersectarray, nintersectarray) + ccall((:SCIPcomputeArraysIntersection, libscip), SCIP_RETCODE, (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), array1, narray1, array2, narray2, intersectarray, nintersectarray) +end + +function SCIPcomputeArraysSetminus(array1, narray1, array2, narray2, setminusarray, nsetminusarray) + ccall((:SCIPcomputeArraysSetminus, libscip), SCIP_RETCODE, (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), array1, narray1, array2, narray2, setminusarray, nsetminusarray) +end + +function SCIPmemccpy(dest, src, stop, cnt) + ccall((:SCIPmemccpy, libscip), Cint, (Cstring, Cstring, UInt8, UInt32), dest, src, stop, cnt) +end + +function SCIPprintSysError(message) + ccall((:SCIPprintSysError, libscip), Cvoid, (Cstring,), message) +end + +function SCIPstrtok(s, delim, ptrptr) + ccall((:SCIPstrtok, libscip), Cstring, (Cstring, Cstring, Ptr{Cstring}), s, delim, ptrptr) +end + +function SCIPescapeString(t, bufsize, s) + ccall((:SCIPescapeString, libscip), Cvoid, (Cstring, Cint, Cstring), t, bufsize, s) +end + +function SCIPstrncpy(t, s, size) + ccall((:SCIPstrncpy, libscip), Cint, (Cstring, Cstring, Cint), t, s, size) +end + +function SCIPstrToIntValue(str, value, endptr) + ccall((:SCIPstrToIntValue, libscip), UInt32, (Cstring, Ptr{Cint}, Ptr{Cstring}), str, value, endptr) +end + +function SCIPstrToRealValue(str, value, endptr) + ccall((:SCIPstrToRealValue, libscip), UInt32, (Cstring, Ptr{Cdouble}, Ptr{Cstring}), str, value, endptr) +end + +function SCIPstrCopySection(str, startchar, endchar, token, size, endptr) + ccall((:SCIPstrCopySection, libscip), Cvoid, (Cstring, UInt8, UInt8, Cstring, Cint, Ptr{Cstring}), str, startchar, endchar, token, size, endptr) +end + +function SCIPfileExists(filename) + ccall((:SCIPfileExists, libscip), UInt32, (Cstring,), filename) +end + +function SCIPsplitFilename(filename, path, name, extension, compression) + ccall((:SCIPsplitFilename, libscip), Cvoid, (Cstring, Ptr{Cstring}, Ptr{Cstring}, Ptr{Cstring}, Ptr{Cstring}), filename, path, name, extension, compression) +end diff --git a/src/wrapper/pub_misc_linear.jl b/src/wrapper/pub_misc_linear.jl new file mode 100644 index 00000000..20d318f7 --- /dev/null +++ b/src/wrapper/pub_misc_linear.jl @@ -0,0 +1,27 @@ +# Julia wrapper for header: /usr/include/scip/pub_misc_linear.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPconsGetRhs(scip, cons, success) + ccall((:SCIPconsGetRhs, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{UInt32}), scip, cons, success) +end + +function SCIPconsGetLhs(scip, cons, success) + ccall((:SCIPconsGetLhs, libscip), Cdouble, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{UInt32}), scip, cons, success) +end + +function SCIPgetConsVals(scip, cons, vals, varssize, success) + ccall((:SCIPgetConsVals, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Cint, Ptr{UInt32}), scip, cons, vals, varssize, success) +end + +function SCIPconsGetDualfarkas(scip, cons, dualfarkas, success) + ccall((:SCIPconsGetDualfarkas, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{UInt32}), scip, cons, dualfarkas, success) +end + +function SCIPconsGetDualsol(scip, cons, dualsol, success) + ccall((:SCIPconsGetDualsol, libscip), Cvoid, (Ptr{SCIP_}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{UInt32}), scip, cons, dualsol, success) +end + +function SCIPconsGetRow(scip, cons) + ccall((:SCIPconsGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_}, Ptr{SCIP_CONS}), scip, cons) +end diff --git a/src/wrapper/pub_misc_select.jl b/src/wrapper/pub_misc_select.jl new file mode 100644 index 00000000..2549ddf7 --- /dev/null +++ b/src/wrapper/pub_misc_select.jl @@ -0,0 +1,939 @@ +# Julia wrapper for header: /usr/include/scip/pub_misc_select.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPselectInd(indarray, indcomp, dataptr, k, len) + ccall((:SCIPselectInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint), indarray, indcomp, dataptr, k, len) +end + +function SCIPselectWeightedInd(indarray, indcomp, dataptr, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), indarray, indcomp, dataptr, weights, capacity, len, medianpos) +end + +function SCIPselectPtr(ptrarray, ptrcomp, k, len) + ccall((:SCIPselectPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Cint), ptrarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtr(ptrarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrPtr(ptrarray1, ptrarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrPtr(ptrarray1, ptrarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrReal(ptrarray, realarray, ptrcomp, k, len) + ccall((:SCIPselectPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrReal(ptrarray, realarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrInt(ptrarray, intarray, ptrcomp, k, len) + ccall((:SCIPselectPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrInt(ptrarray, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrBool(ptrarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Cint), ptrarray, boolarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrBool(ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, intarray1, intarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrRealInt(ptrarray, realarray, intarray, ptrcomp, k, len) + ccall((:SCIPselectPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrRealInt(ptrarray, realarray, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrRealRealInt(ptrarray, realarray1, realarray2, intarray, ptrcomp, k, len) + ccall((:SCIPselectPtrRealRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray1, realarray2, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrRealRealInt(ptrarray, realarray1, realarray2, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrRealRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, boolarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrRealReal(ptrarray, realarray1, realarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrRealReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray1, realarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrRealReal(ptrarray, realarray1, realarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrRealReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, k, len) + ccall((:SCIPselectPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, k, len) + ccall((:SCIPselectPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, intarray1, intarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, k, len) + ccall((:SCIPselectPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, k, len) + ccall((:SCIPselectPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectReal(realarray, k, len) + ccall((:SCIPselectReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Cint), realarray, k, len) +end + +function SCIPselectWeightedReal(realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedReal, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealPtr(realarray, ptrarray, k, len) + ccall((:SCIPselectRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, ptrarray, k, len) +end + +function SCIPselectWeightedRealPtr(realarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealInt(realarray, intarray, k, len) + ccall((:SCIPselectRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray, intarray, k, len) +end + +function SCIPselectWeightedRealInt(realarray, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealIntInt(realarray, intarray1, intarray2, k, len) + ccall((:SCIPselectRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), realarray, intarray1, intarray2, k, len) +end + +function SCIPselectWeightedRealIntInt(realarray, intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectRealBoolPtr(realarray, boolarray, ptrarray, k, len) + ccall((:SCIPselectRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, boolarray, ptrarray, k, len) +end + +function SCIPselectWeightedRealBoolPtr(realarray, boolarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealIntLong(realarray, intarray, longarray, k, len) + ccall((:SCIPselectRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint, Cint), realarray, intarray, longarray, k, len) +end + +function SCIPselectWeightedRealIntLong(realarray, intarray, longarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, intarray, longarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealIntPtr(realarray, intarray, ptrarray, k, len) + ccall((:SCIPselectRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, intarray, ptrarray, k, len) +end + +function SCIPselectWeightedRealIntPtr(realarray, intarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, intarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealRealPtr(realarray1, realarray2, ptrarray, k, len) + ccall((:SCIPselectRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, ptrarray, k, len) +end + +function SCIPselectWeightedRealRealPtr(realarray1, realarray2, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, k, len) + ccall((:SCIPselectRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Cint), realarray, ptrarray1, ptrarray2, intarray, k, len) +end + +function SCIPselectWeightedRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, k, len) + ccall((:SCIPselectRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), realarray, ptrarray1, ptrarray2, intarray1, intarray2, k, len) +end + +function SCIPselectWeightedRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectRealLongRealInt(realarray1, longarray, realarray3, intarray, k, len) + ccall((:SCIPselectRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray1, longarray, realarray3, intarray, k, len) +end + +function SCIPselectWeightedRealLongRealInt(realarray1, longarray, realarray3, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, longarray, realarray3, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealRealIntInt(realarray1, realarray2, intarray1, intarray2, k, len) + ccall((:SCIPselectRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), realarray1, realarray2, intarray1, intarray2, k, len) +end + +function SCIPselectWeightedRealRealIntInt(realarray1, realarray2, intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectRealRealRealInt(realarray1, realarray2, realarray3, intarray, k, len) + ccall((:SCIPselectRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray1, realarray2, realarray3, intarray, k, len) +end + +function SCIPselectWeightedRealRealRealInt(realarray1, realarray2, realarray3, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, k, len) + ccall((:SCIPselectRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, ptrarray, k, len) +end + +function SCIPselectWeightedRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) + ccall((:SCIPselectRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) +end + +function SCIPselectWeightedRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, k, len) + ccall((:SCIPselectRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, k, len) +end + +function SCIPselectWeightedRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectInt(intarray, k, len) + ccall((:SCIPselectInt, libscip), Cvoid, (Ptr{Cint}, Cint, Cint), intarray, k, len) +end + +function SCIPselectWeightedInt(intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntInt(intarray1, intarray2, k, len) + ccall((:SCIPselectIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Cint), intarray1, intarray2, k, len) +end + +function SCIPselectWeightedIntInt(intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectIntPtr(intarray, ptrarray, k, len) + ccall((:SCIPselectIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray, ptrarray, k, len) +end + +function SCIPselectWeightedIntPtr(intarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntReal(intarray, realarray, k, len) + ccall((:SCIPselectIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray, realarray, k, len) +end + +function SCIPselectWeightedIntReal(intarray, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntIntInt(intarray1, intarray2, intarray3, k, len) + ccall((:SCIPselectIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), intarray1, intarray2, intarray3, k, len) +end + +function SCIPselectWeightedIntIntInt(intarray1, intarray2, intarray3, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, weights, capacity, len, medianpos) +end + +function SCIPselectIntIntLong(intarray1, intarray2, longarray, k, len) + ccall((:SCIPselectIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint, Cint), intarray1, intarray2, longarray, k, len) +end + +function SCIPselectWeightedIntIntLong(intarray1, intarray2, longarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, longarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntRealLong(intarray, realarray, longarray, k, len) + ccall((:SCIPselectIntRealLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Cint, Cint), intarray, realarray, longarray, k, len) +end + +function SCIPselectWeightedIntRealLong(intarray, realarray, longarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntRealLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray, realarray, longarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntIntPtr(intarray1, intarray2, ptrarray, k, len) + ccall((:SCIPselectIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray1, intarray2, ptrarray, k, len) +end + +function SCIPselectWeightedIntIntPtr(intarray1, intarray2, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntIntReal(intarray1, intarray2, realarray, k, len) + ccall((:SCIPselectIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray1, intarray2, realarray, k, len) +end + +function SCIPselectWeightedIntIntReal(intarray1, intarray2, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntPtrReal(intarray, ptrarray, realarray, k, len) + ccall((:SCIPselectIntPtrReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cint, Cint), intarray, ptrarray, realarray, k, len) +end + +function SCIPselectWeightedIntPtrReal(intarray, ptrarray, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntPtrReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray, ptrarray, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, k, len) + ccall((:SCIPselectIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray1, intarray2, intarray3, ptrarray, k, len) +end + +function SCIPselectWeightedIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntIntIntReal(intarray1, intarray2, intarray3, realarray, k, len) + ccall((:SCIPselectIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray1, intarray2, intarray3, realarray, k, len) +end + +function SCIPselectWeightedIntIntIntReal(intarray1, intarray2, intarray3, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, k, len) + ccall((:SCIPselectIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray1, ptrarray, intarray2, realarray, k, len) +end + +function SCIPselectWeightedIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectLong(longarray, k, len) + ccall((:SCIPselectLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Cint), longarray, k, len) +end + +function SCIPselectWeightedLong(longarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLong, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, weights, capacity, len, medianpos) +end + +function SCIPselectLongPtr(longarray, ptrarray, k, len) + ccall((:SCIPselectLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Cint), longarray, ptrarray, k, len) +end + +function SCIPselectWeightedLongPtr(longarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectLongPtrInt(longarray, ptrarray, intarray, k, len) + ccall((:SCIPselectLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Cint), longarray, ptrarray, intarray, k, len) +end + +function SCIPselectWeightedLongPtrInt(longarray, ptrarray, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectLongPtrRealBool(longarray, ptrarray, realarray, boolarray, k, len) + ccall((:SCIPselectLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Cint, Cint), longarray, ptrarray, realarray, boolarray, k, len) +end + +function SCIPselectWeightedLongPtrRealBool(longarray, ptrarray, realarray, boolarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, weights, capacity, len, medianpos) +end + +function SCIPselectLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, k, len) + ccall((:SCIPselectLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Cint, Cint), longarray, ptrarray, realarray, realarray2, boolarray, k, len) +end + +function SCIPselectWeightedLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, weights, capacity, len, medianpos) +end + +function SCIPselectLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, k, len) + ccall((:SCIPselectLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Cint, Cint), longarray, ptrarray, realarray, realarray2, intarray, boolarray, k, len) +end + +function SCIPselectWeightedLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, weights, capacity, len, medianpos) +end + +function SCIPselectLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, k, len) + ccall((:SCIPselectLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Cint), longarray, ptrarray1, ptrarray2, intarray, k, len) +end + +function SCIPselectWeightedLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, k, len) + ccall((:SCIPselectLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), longarray, ptrarray1, ptrarray2, intarray1, intarray2, k, len) +end + +function SCIPselectWeightedLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, k, len) + ccall((:SCIPselectLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Cint, Cint), longarray, ptrarray1, ptrarray2, boolarray, intarray, k, len) +end + +function SCIPselectWeightedLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Cint), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, k, len) + ccall((:SCIPselectIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Cint, Cint), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, k, len) +end + +function SCIPselectWeightedIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, weights, capacity, len, medianpos) +end + +function SCIPselectDownInd(indarray, indcomp, dataptr, k, len) + ccall((:SCIPselectDownInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint), indarray, indcomp, dataptr, k, len) +end + +function SCIPselectWeightedDownInd(indarray, indcomp, dataptr, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), indarray, indcomp, dataptr, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtr(ptrarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Cint), ptrarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtr(ptrarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrPtr(ptrarray1, ptrarray2, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrPtr(ptrarray1, ptrarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrReal(ptrarray, realarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrReal(ptrarray, realarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrInt(ptrarray, intarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrInt(ptrarray, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrBool(ptrarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Cint), ptrarray, boolarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrBool(ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, k, len) + ccall((:SCIPselectDownPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, intarray1, intarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrRealInt(ptrarray, realarray, intarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrRealInt(ptrarray, realarray, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, boolarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, k, len) + ccall((:SCIPselectDownPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, intarray1, intarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownReal(realarray, k, len) + ccall((:SCIPselectDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Cint), realarray, k, len) +end + +function SCIPselectWeightedDownReal(realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownReal, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealPtr(realarray, ptrarray, k, len) + ccall((:SCIPselectDownRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, ptrarray, k, len) +end + +function SCIPselectWeightedDownRealPtr(realarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealInt(realarray, intarray, k, len) + ccall((:SCIPselectDownRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray, intarray, k, len) +end + +function SCIPselectDownRealIntInt(realarray, intarray1, intarray2, k, len) + ccall((:SCIPselectDownRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), realarray, intarray1, intarray2, k, len) +end + +function SCIPselectWeightedDownRealInt(realarray, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectWeightedDownRealIntInt(realarray, intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealBoolPtr(realarray, boolarray, ptrarray, k, len) + ccall((:SCIPselectDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, boolarray, ptrarray, k, len) +end + +function SCIPselectWeightedDownRealBoolPtr(realarray, boolarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealIntLong(realarray, intarray, longarray, k, len) + ccall((:SCIPselectDownRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint, Cint), realarray, intarray, longarray, k, len) +end + +function SCIPselectWeightedDownRealIntLong(realarray, intarray, longarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, intarray, longarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealIntPtr(realarray, intarray, ptrarray, k, len) + ccall((:SCIPselectDownRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, intarray, ptrarray, k, len) +end + +function SCIPselectWeightedDownRealIntPtr(realarray, intarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, intarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealRealInt(realarray1, realarray2, intarray, k, len) + ccall((:SCIPselectDownRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray1, realarray2, intarray, k, len) +end + +function SCIPselectWeightedDownRealRealInt(realarray1, realarray2, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealRealPtr(realarray1, realarray2, ptrarray, k, len) + ccall((:SCIPselectDownRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, ptrarray, k, len) +end + +function SCIPselectWeightedDownRealRealPtr(realarray1, realarray2, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealRealPtrPtr(realarray1, realarray2, ptrarray1, ptrarray2, k, len) + ccall((:SCIPselectDownRealRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, ptrarray1, ptrarray2, k, len) +end + +function SCIPselectWeightedDownRealRealPtrPtr(realarray1, realarray2, ptrarray1, ptrarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, ptrarray1, ptrarray2, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, k, len) + ccall((:SCIPselectDownRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Cint), realarray, ptrarray1, ptrarray2, intarray, k, len) +end + +function SCIPselectWeightedDownRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, k, len) + ccall((:SCIPselectDownRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), realarray, ptrarray1, ptrarray2, intarray1, intarray2, k, len) +end + +function SCIPselectWeightedDownRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealLongRealInt(realarray1, longarray, realarray3, intarray, k, len) + ccall((:SCIPselectDownRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray1, longarray, realarray3, intarray, k, len) +end + +function SCIPselectWeightedDownRealLongRealInt(realarray1, longarray, realarray3, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, longarray, realarray3, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealRealIntInt(realarray1, realarray2, intarray1, intarray2, k, len) + ccall((:SCIPselectDownRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), realarray1, realarray2, intarray1, intarray2, k, len) +end + +function SCIPselectWeightedDownRealRealIntInt(realarray1, realarray2, intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealRealRealInt(realarray1, realarray2, realarray3, intarray, k, len) + ccall((:SCIPselectDownRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray1, realarray2, realarray3, intarray, k, len) +end + +function SCIPselectWeightedDownRealRealRealInt(realarray1, realarray2, realarray3, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, k, len) + ccall((:SCIPselectDownRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, ptrarray, k, len) +end + +function SCIPselectWeightedDownRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealPtrPtr(realarray, ptrarray1, ptrarray2, k, len) + ccall((:SCIPselectDownRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, ptrarray1, ptrarray2, k, len) +end + +function SCIPselectWeightedDownRealPtrPtr(realarray, ptrarray1, ptrarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) + ccall((:SCIPselectDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) +end + +function SCIPselectWeightedDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, k, len) + ccall((:SCIPselectDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, k, len) +end + +function SCIPselectWeightedDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownInt(intarray, k, len) + ccall((:SCIPselectDownInt, libscip), Cvoid, (Ptr{Cint}, Cint, Cint), intarray, k, len) +end + +function SCIPselectWeightedDownInt(intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntInt(intarray1, intarray2, k, len) + ccall((:SCIPselectDownIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Cint), intarray1, intarray2, k, len) +end + +function SCIPselectWeightedDownIntInt(intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntPtr(intarray, ptrarray, k, len) + ccall((:SCIPselectDownIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray, ptrarray, k, len) +end + +function SCIPselectWeightedDownIntPtr(intarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntReal(intarray, realarray, k, len) + ccall((:SCIPselectDownIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray, realarray, k, len) +end + +function SCIPselectWeightedDownIntReal(intarray, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntIntInt(intarray1, intarray2, intarray3, k, len) + ccall((:SCIPselectDownIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), intarray1, intarray2, intarray3, k, len) +end + +function SCIPselectWeightedDownIntIntInt(intarray1, intarray2, intarray3, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntIntLong(intarray1, intarray2, longarray, k, len) + ccall((:SCIPselectDownIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint, Cint), intarray1, intarray2, longarray, k, len) +end + +function SCIPselectWeightedDownIntIntLong(intarray1, intarray2, longarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, longarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntIntPtr(intarray1, intarray2, ptrarray, k, len) + ccall((:SCIPselectDownIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray1, intarray2, ptrarray, k, len) +end + +function SCIPselectWeightedDownIntIntPtr(intarray1, intarray2, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntIntReal(intarray1, intarray2, realarray, k, len) + ccall((:SCIPselectDownIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray1, intarray2, realarray, k, len) +end + +function SCIPselectWeightedDownIntIntReal(intarray1, intarray2, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, k, len) + ccall((:SCIPselectDownIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray1, intarray2, intarray3, ptrarray, k, len) +end + +function SCIPselectWeightedDownIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntIntIntReal(intarray1, intarray2, intarray3, realarray, k, len) + ccall((:SCIPselectDownIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray1, intarray2, intarray3, realarray, k, len) +end + +function SCIPselectWeightedDownIntIntIntReal(intarray1, intarray2, intarray3, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, k, len) + ccall((:SCIPselectDownIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray1, ptrarray, intarray2, realarray, k, len) +end + +function SCIPselectWeightedDownIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, realarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownLong(longarray, k, len) + ccall((:SCIPselectDownLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Cint), longarray, k, len) +end + +function SCIPselectWeightedDownLong(longarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLong, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownLongPtr(longarray, ptrarray, k, len) + ccall((:SCIPselectDownLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Cint), longarray, ptrarray, k, len) +end + +function SCIPselectWeightedDownLongPtr(longarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownLongPtrInt(longarray, ptrarray, intarray, k, len) + ccall((:SCIPselectDownLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Cint), longarray, ptrarray, intarray, k, len) +end + +function SCIPselectWeightedDownLongPtrInt(longarray, ptrarray, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, k, len) + ccall((:SCIPselectDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Cint, Cint), longarray, ptrarray, realarray, boolarray, k, len) +end + +function SCIPselectWeightedDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, k, len) + ccall((:SCIPselectDownLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Cint, Cint), longarray, ptrarray, realarray, realarray2, boolarray, k, len) +end + +function SCIPselectWeightedDownLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, k, len) + ccall((:SCIPselectDownLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Cint, Cint), longarray, ptrarray, realarray, realarray2, intarray, boolarray, k, len) +end + +function SCIPselectWeightedDownLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, k, len) + ccall((:SCIPselectDownLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Cint), longarray, ptrarray1, ptrarray2, intarray, k, len) +end + +function SCIPselectWeightedDownLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, k, len) + ccall((:SCIPselectDownLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), longarray, ptrarray1, ptrarray2, intarray1, intarray2, k, len) +end + +function SCIPselectWeightedDownLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray1, intarray2, weights, capacity, len, medianpos) +end + +function SCIPselectDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, k, len) + ccall((:SCIPselectDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Cint, Cint), longarray, ptrarray1, ptrarray2, boolarray, intarray, k, len) +end + +function SCIPselectWeightedDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, weights, capacity, len, medianpos) +end + +function SCIPselectDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, k, len) + ccall((:SCIPselectDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Cint), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, k, len) +end + +function SCIPselectWeightedDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) +end + +function SCIPselectDownIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, k, len) + ccall((:SCIPselectDownIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Cint, Cint), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, k, len) +end + +function SCIPselectWeightedDownIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, weights, capacity, len, medianpos) +end diff --git a/src/wrapper/pub_misc_sort.jl b/src/wrapper/pub_misc_sort.jl new file mode 100644 index 00000000..476d7c5a --- /dev/null +++ b/src/wrapper/pub_misc_sort.jl @@ -0,0 +1,1451 @@ +# Julia wrapper for header: /usr/include/scip/pub_misc_sort.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPsortCompInt(elem1, elem2) + ccall((:SCIPsortCompInt, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPsort(perm, indcomp, dataptr, len) + ccall((:SCIPsort, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), perm, indcomp, dataptr, len) +end + +function SCIPsortInd(indarray, indcomp, dataptr, len) + ccall((:SCIPsortInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), indarray, indcomp, dataptr, len) +end + +function SCIPsortPtr(ptrarray, ptrcomp, len) + ccall((:SCIPsortPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), ptrarray, ptrcomp, len) +end + +function SCIPsortPtrPtr(ptrarray1, ptrarray2, ptrcomp, len) + ccall((:SCIPsortPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, ptrcomp, len) +end + +function SCIPsortPtrReal(ptrarray, realarray, ptrcomp, len) + ccall((:SCIPsortPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), ptrarray, realarray, ptrcomp, len) +end + +function SCIPsortPtrInt(ptrarray, intarray, ptrcomp, len) + ccall((:SCIPsortPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, intarray, ptrcomp, len) +end + +function SCIPsortPtrBool(ptrarray, boolarray, ptrcomp, len) + ccall((:SCIPsortPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Cint), ptrarray, boolarray, ptrcomp, len) +end + +function SCIPsortPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, len) + ccall((:SCIPsortPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, intarray1, intarray2, ptrcomp, len) +end + +function SCIPsortPtrRealInt(ptrarray, realarray, intarray, ptrcomp, len) + ccall((:SCIPsortPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, realarray, intarray, ptrcomp, len) +end + +function SCIPsortPtrRealRealInt(ptrarray, realarray1, realarray2, intarray, ptrcomp, len) + ccall((:SCIPsortPtrRealRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, realarray1, realarray2, intarray, ptrcomp, len) +end + +function SCIPsortPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) + ccall((:SCIPsortPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint), ptrarray, realarray, boolarray, ptrcomp, len) +end + +function SCIPsortPtrRealReal(ptrarray, realarray1, realarray2, ptrcomp, len) + ccall((:SCIPsortPtrRealReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), ptrarray, realarray1, realarray2, ptrcomp, len) +end + +function SCIPsortPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, len) + ccall((:SCIPsortPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, intarray, ptrcomp, len) +end + +function SCIPsortPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, len) + ccall((:SCIPsortPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, realarray, ptrcomp, len) +end + +function SCIPsortPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, len) + ccall((:SCIPsortPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, len) +end + +function SCIPsortPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, len) + ccall((:SCIPsortPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, realarray, intarray1, intarray2, ptrcomp, len) +end + +function SCIPsortPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, len) + ccall((:SCIPsortPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, len) +end + +function SCIPsortPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, len) + ccall((:SCIPsortPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, len) +end + +function SCIPsortPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, len) + ccall((:SCIPsortPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, len) +end + +function SCIPsortPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, len) + ccall((:SCIPsortPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, len) +end + +function SCIPsortReal(realarray, len) + ccall((:SCIPsortReal, libscip), Cvoid, (Ptr{Cdouble}, Cint), realarray, len) +end + +function SCIPsortRealPtr(realarray, ptrarray, len) + ccall((:SCIPsortRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray, ptrarray, len) +end + +function SCIPsortRealInt(realarray, intarray, len) + ccall((:SCIPsortRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint), realarray, intarray, len) +end + +function SCIPsortRealIntInt(realarray, intarray1, intarray2, len) + ccall((:SCIPsortRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), realarray, intarray1, intarray2, len) +end + +function SCIPsortRealBoolPtr(realarray, boolarray, ptrarray, len) + ccall((:SCIPsortRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint), realarray, boolarray, ptrarray, len) +end + +function SCIPsortRealIntLong(realarray, intarray, longarray, len) + ccall((:SCIPsortRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint), realarray, intarray, longarray, len) +end + +function SCIPsortRealIntPtr(realarray, intarray, ptrarray, len) + ccall((:SCIPsortRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), realarray, intarray, ptrarray, len) +end + +function SCIPsortRealRealPtr(realarray1, realarray2, ptrarray, len) + ccall((:SCIPsortRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, ptrarray, len) +end + +function SCIPsortRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, len) + ccall((:SCIPsortRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), realarray, ptrarray1, ptrarray2, intarray, len) +end + +function SCIPsortRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, len) + ccall((:SCIPsortRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint), realarray, ptrarray1, ptrarray2, intarray1, intarray2, len) +end + +function SCIPsortRealLongRealInt(realarray1, longarray, realarray3, intarray, len) + ccall((:SCIPsortRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Cint), realarray1, longarray, realarray3, intarray, len) +end + +function SCIPsortRealRealIntInt(realarray1, realarray2, intarray1, intarray2, len) + ccall((:SCIPsortRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), realarray1, realarray2, intarray1, intarray2, len) +end + +function SCIPsortRealRealRealInt(realarray1, realarray2, realarray3, intarray, len) + ccall((:SCIPsortRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint), realarray1, realarray2, realarray3, intarray, len) +end + +function SCIPsortRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, len) + ccall((:SCIPsortRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, ptrarray, len) +end + +function SCIPsortRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, len) + ccall((:SCIPsortRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, len) +end + +function SCIPsortRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, len) + ccall((:SCIPsortRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, len) +end + +function SCIPsortInt(intarray, len) + ccall((:SCIPsortInt, libscip), Cvoid, (Ptr{Cint}, Cint), intarray, len) +end + +function SCIPsortIntInt(intarray1, intarray2, len) + ccall((:SCIPsortIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint), intarray1, intarray2, len) +end + +function SCIPsortIntPtr(intarray, ptrarray, len) + ccall((:SCIPsortIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray, ptrarray, len) +end + +function SCIPsortIntReal(intarray, realarray, len) + ccall((:SCIPsortIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint), intarray, realarray, len) +end + +function SCIPsortIntIntInt(intarray1, intarray2, intarray3, len) + ccall((:SCIPsortIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint), intarray1, intarray2, intarray3, len) +end + +function SCIPsortIntIntLong(intarray1, intarray2, longarray, len) + ccall((:SCIPsortIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint), intarray1, intarray2, longarray, len) +end + +function SCIPsortIntRealLong(intarray, realarray, longarray, len) + ccall((:SCIPsortIntRealLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Cint), intarray, realarray, longarray, len) +end + +function SCIPsortIntIntPtr(intarray1, intarray2, ptrarray, len) + ccall((:SCIPsortIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray1, intarray2, ptrarray, len) +end + +function SCIPsortIntIntReal(intarray1, intarray2, realarray, len) + ccall((:SCIPsortIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint), intarray1, intarray2, realarray, len) +end + +function SCIPsortIntPtrReal(intarray, ptrarray, realarray, len) + ccall((:SCIPsortIntPtrReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cint), intarray, ptrarray, realarray, len) +end + +function SCIPsortIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, len) + ccall((:SCIPsortIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray1, intarray2, intarray3, ptrarray, len) +end + +function SCIPsortIntIntIntReal(intarray1, intarray2, intarray3, realarray, len) + ccall((:SCIPsortIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint), intarray1, intarray2, intarray3, realarray, len) +end + +function SCIPsortIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, len) + ccall((:SCIPsortIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cint), intarray1, ptrarray, intarray2, realarray, len) +end + +function SCIPsortLong(longarray, len) + ccall((:SCIPsortLong, libscip), Cvoid, (Ptr{Clonglong}, Cint), longarray, len) +end + +function SCIPsortLongPtr(longarray, ptrarray, len) + ccall((:SCIPsortLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint), longarray, ptrarray, len) +end + +function SCIPsortLongPtrInt(longarray, ptrarray, intarray, len) + ccall((:SCIPsortLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), longarray, ptrarray, intarray, len) +end + +function SCIPsortLongPtrRealBool(longarray, ptrarray, realarray, boolarray, len) + ccall((:SCIPsortLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Cint), longarray, ptrarray, realarray, boolarray, len) +end + +function SCIPsortLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, len) + ccall((:SCIPsortLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Cint), longarray, ptrarray, realarray, realarray2, boolarray, len) +end + +function SCIPsortLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, len) + ccall((:SCIPsortLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Cint), longarray, ptrarray, realarray, realarray2, intarray, boolarray, len) +end + +function SCIPsortLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, len) + ccall((:SCIPsortLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), longarray, ptrarray1, ptrarray2, intarray, len) +end + +function SCIPsortLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, len) + ccall((:SCIPsortLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint), longarray, ptrarray1, ptrarray2, intarray1, intarray2, len) +end + +function SCIPsortLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, len) + ccall((:SCIPsortLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Cint), longarray, ptrarray1, ptrarray2, boolarray, intarray, len) +end + +function SCIPsortPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, len) + ccall((:SCIPsortPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Cint), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, len) +end + +function SCIPsortIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, len) + ccall((:SCIPsortIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Cint), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, len) +end + +function SCIPsortDown(perm, indcomp, dataptr, len) + ccall((:SCIPsortDown, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), perm, indcomp, dataptr, len) +end + +function SCIPsortDownInd(indarray, indcomp, dataptr, len) + ccall((:SCIPsortDownInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), indarray, indcomp, dataptr, len) +end + +function SCIPsortDownPtr(ptrarray, ptrcomp, len) + ccall((:SCIPsortDownPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), ptrarray, ptrcomp, len) +end + +function SCIPsortDownPtrPtr(ptrarray1, ptrarray2, ptrcomp, len) + ccall((:SCIPsortDownPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, ptrcomp, len) +end + +function SCIPsortDownPtrReal(ptrarray, realarray, ptrcomp, len) + ccall((:SCIPsortDownPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), ptrarray, realarray, ptrcomp, len) +end + +function SCIPsortDownPtrInt(ptrarray, intarray, ptrcomp, len) + ccall((:SCIPsortDownPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, intarray, ptrcomp, len) +end + +function SCIPsortDownPtrBool(ptrarray, boolarray, ptrcomp, len) + ccall((:SCIPsortDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Cint), ptrarray, boolarray, ptrcomp, len) +end + +function SCIPsortDownPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, len) + ccall((:SCIPsortDownPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, intarray1, intarray2, ptrcomp, len) +end + +function SCIPsortDownPtrRealInt(ptrarray, realarray, intarray, ptrcomp, len) + ccall((:SCIPsortDownPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, realarray, intarray, ptrcomp, len) +end + +function SCIPsortDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) + ccall((:SCIPsortDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint), ptrarray, realarray, boolarray, ptrcomp, len) +end + +function SCIPsortDownPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, len) + ccall((:SCIPsortDownPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, intarray, ptrcomp, len) +end + +function SCIPsortDownPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, len) + ccall((:SCIPsortDownPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, realarray, ptrcomp, len) +end + +function SCIPsortDownPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, len) + ccall((:SCIPsortDownPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, len) +end + +function SCIPsortDownPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, len) + ccall((:SCIPsortDownPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, realarray, intarray1, intarray2, ptrcomp, len) +end + +function SCIPsortDownPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, len) + ccall((:SCIPsortDownPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, len) +end + +function SCIPsortDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, len) + ccall((:SCIPsortDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, len) +end + +function SCIPsortDownPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, len) + ccall((:SCIPsortDownPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, len) +end + +function SCIPsortDownPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, len) + ccall((:SCIPsortDownPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, len) +end + +function SCIPsortDownReal(realarray, len) + ccall((:SCIPsortDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cint), realarray, len) +end + +function SCIPsortDownRealPtr(realarray, ptrarray, len) + ccall((:SCIPsortDownRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray, ptrarray, len) +end + +function SCIPsortDownRealInt(realarray, intarray, len) + ccall((:SCIPsortDownRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint), realarray, intarray, len) +end + +function SCIPsortDownRealIntInt(realarray, intarray1, intarray2, len) + ccall((:SCIPsortDownRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), realarray, intarray1, intarray2, len) +end + +function SCIPsortDownRealBoolPtr(realarray, boolarray, ptrarray, len) + ccall((:SCIPsortDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint), realarray, boolarray, ptrarray, len) +end + +function SCIPsortDownRealIntLong(realarray, intarray, longarray, len) + ccall((:SCIPsortDownRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint), realarray, intarray, longarray, len) +end + +function SCIPsortDownRealIntPtr(realarray, intarray, ptrarray, len) + ccall((:SCIPsortDownRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), realarray, intarray, ptrarray, len) +end + +function SCIPsortDownRealRealInt(realarray1, realarray2, intarray, len) + ccall((:SCIPsortDownRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint), realarray1, realarray2, intarray, len) +end + +function SCIPsortDownRealRealPtr(realarray1, realarray2, ptrarray, len) + ccall((:SCIPsortDownRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, ptrarray, len) +end + +function SCIPsortDownRealRealPtrPtr(realarray1, realarray2, ptrarray1, ptrarray2, len) + ccall((:SCIPsortDownRealRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, ptrarray1, ptrarray2, len) +end + +function SCIPsortDownRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, len) + ccall((:SCIPsortDownRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), realarray, ptrarray1, ptrarray2, intarray, len) +end + +function SCIPsortDownRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, len) + ccall((:SCIPsortDownRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint), realarray, ptrarray1, ptrarray2, intarray1, intarray2, len) +end + +function SCIPsortDownRealLongRealInt(realarray1, longarray, realarray3, intarray, len) + ccall((:SCIPsortDownRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Cint), realarray1, longarray, realarray3, intarray, len) +end + +function SCIPsortDownRealRealIntInt(realarray1, realarray2, intarray1, intarray2, len) + ccall((:SCIPsortDownRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), realarray1, realarray2, intarray1, intarray2, len) +end + +function SCIPsortDownRealRealRealInt(realarray1, realarray2, realarray3, intarray, len) + ccall((:SCIPsortDownRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint), realarray1, realarray2, realarray3, intarray, len) +end + +function SCIPsortDownRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, len) + ccall((:SCIPsortDownRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, ptrarray, len) +end + +function SCIPsortDownRealPtrPtr(realarray, ptrarray1, ptrarray2, len) + ccall((:SCIPsortDownRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), realarray, ptrarray1, ptrarray2, len) +end + +function SCIPsortDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, len) + ccall((:SCIPsortDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, len) +end + +function SCIPsortDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, len) + ccall((:SCIPsortDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, len) +end + +function SCIPsortDownInt(intarray, len) + ccall((:SCIPsortDownInt, libscip), Cvoid, (Ptr{Cint}, Cint), intarray, len) +end + +function SCIPsortDownIntInt(intarray1, intarray2, len) + ccall((:SCIPsortDownIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint), intarray1, intarray2, len) +end + +function SCIPsortDownIntPtr(intarray, ptrarray, len) + ccall((:SCIPsortDownIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray, ptrarray, len) +end + +function SCIPsortDownIntReal(intarray, realarray, len) + ccall((:SCIPsortDownIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint), intarray, realarray, len) +end + +function SCIPsortDownIntIntInt(intarray1, intarray2, intarray3, len) + ccall((:SCIPsortDownIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint), intarray1, intarray2, intarray3, len) +end + +function SCIPsortDownIntIntLong(intarray1, intarray2, longarray, len) + ccall((:SCIPsortDownIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint), intarray1, intarray2, longarray, len) +end + +function SCIPsortDownIntIntPtr(intarray1, intarray2, ptrarray, len) + ccall((:SCIPsortDownIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray1, intarray2, ptrarray, len) +end + +function SCIPsortDownIntIntReal(intarray1, intarray2, realarray, len) + ccall((:SCIPsortDownIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint), intarray1, intarray2, realarray, len) +end + +function SCIPsortDownIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, len) + ccall((:SCIPsortDownIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray1, intarray2, intarray3, ptrarray, len) +end + +function SCIPsortDownIntIntIntReal(intarray1, intarray2, intarray3, realarray, len) + ccall((:SCIPsortDownIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint), intarray1, intarray2, intarray3, realarray, len) +end + +function SCIPsortDownIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, len) + ccall((:SCIPsortDownIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cint), intarray1, ptrarray, intarray2, realarray, len) +end + +function SCIPsortDownLong(longarray, len) + ccall((:SCIPsortDownLong, libscip), Cvoid, (Ptr{Clonglong}, Cint), longarray, len) +end + +function SCIPsortDownLongPtr(longarray, ptrarray, len) + ccall((:SCIPsortDownLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint), longarray, ptrarray, len) +end + +function SCIPsortDownLongPtrInt(longarray, ptrarray, intarray, len) + ccall((:SCIPsortDownLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), longarray, ptrarray, intarray, len) +end + +function SCIPsortDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, len) + ccall((:SCIPsortDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Cint), longarray, ptrarray, realarray, boolarray, len) +end + +function SCIPsortDownLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, len) + ccall((:SCIPsortDownLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Cint), longarray, ptrarray, realarray, realarray2, boolarray, len) +end + +function SCIPsortDownLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, len) + ccall((:SCIPsortDownLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Cint), longarray, ptrarray, realarray, realarray2, intarray, boolarray, len) +end + +function SCIPsortDownLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, len) + ccall((:SCIPsortDownLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), longarray, ptrarray1, ptrarray2, intarray, len) +end + +function SCIPsortDownLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, len) + ccall((:SCIPsortDownLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint), longarray, ptrarray1, ptrarray2, intarray1, intarray2, len) +end + +function SCIPsortDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, len) + ccall((:SCIPsortDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Cint), longarray, ptrarray1, ptrarray2, boolarray, intarray, len) +end + +function SCIPsortDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, len) + ccall((:SCIPsortDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Cint), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, len) +end + +function SCIPsortDownIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, len) + ccall((:SCIPsortDownIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Cint), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, len) +end + +function SCIPsortedvecInsertInd(indarray, indcomp, dataptr, keyval, len, pos) + ccall((:SCIPsortedvecInsertInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), indarray, indcomp, dataptr, keyval, len, pos) +end + +function SCIPsortedvecInsertPtr(ptrarray, ptrcomp, keyval, len, pos) + ccall((:SCIPsortedvecInsertPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), ptrarray, ptrcomp, keyval, len, pos) +end + +function SCIPsortedvecInsertPtrPtr(ptrarray1, ptrarray2, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, ptrcomp, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertPtrReal(ptrarray, realarray, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, ptrcomp, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertPtrInt(ptrarray, intarray, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray, ptrcomp, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertPtrBool(ptrarray, boolarray, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cvoid}, UInt32, Ptr{Cint}, Ptr{Cint}), ptrarray, boolarray, ptrcomp, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertPtrRealInt(ptrarray, realarray, intarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, intarray, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertPtrRealRealInt(ptrarray, realarray1, realarray2, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertPtrRealRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, UInt32, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, intarray, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, realarray, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cint, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, UInt32, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Clonglong, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Clonglong, Cint, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertRealIntInt(realarray, intarray1, intarray2, keyval, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cdouble, Cint, Cint, Ptr{Cint}, Ptr{Cint}), realarray, intarray1, intarray2, keyval, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertRealBoolPtr(realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cdouble, UInt32, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertRealPtr(realarray, ptrarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cdouble, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, ptrarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertReal(realarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertReal, libscip), Cvoid, (Ptr{Cdouble}, Cdouble, Ptr{Cint}, Ptr{Cint}), realarray, keyval, len, pos) +end + +function SCIPsortedvecInsertRealInt(realarray, intarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), realarray, intarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertRealIntLong(realarray, intarray, longarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cdouble, Cint, Clonglong, Ptr{Cint}, Ptr{Cint}), realarray, intarray, longarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertRealIntPtr(realarray, intarray, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cdouble, Cint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, intarray, ptrarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertRealRealPtr(realarray1, realarray2, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, ptrarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, keyval, field1val, field2val, intval, len, pos) + ccall((:SCIPsortedvecInsertRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray, keyval, field1val, field2val, intval, len, pos) +end + +function SCIPsortedvecInsertRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, keyval, field1val, field2val, intval1, intval2, len, pos) + ccall((:SCIPsortedvecInsertRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray1, intarray2, keyval, field1val, field2val, intval1, intval2, len, pos) +end + +function SCIPsortedvecInsertRealLongRealInt(realarray1, longarray, realarray3, intarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Cdouble, Clonglong, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), realarray1, longarray, realarray3, intarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertRealRealIntInt(realarray1, realarray2, intarray1, intarray2, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cdouble, Cdouble, Cint, Cint, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, intarray1, intarray2, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertRealRealRealInt(realarray1, realarray2, realarray3, intarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cdouble, Cdouble, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, intarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, ptrarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, UInt32, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) + ccall((:SCIPsortedvecInsertRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +end + +function SCIPsortedvecInsertInt(intarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), intarray, keyval, len, pos) +end + +function SCIPsortedvecInsertIntInt(intarray1, intarray2, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertIntPtr(intarray, ptrarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), intarray, ptrarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertIntReal(intarray, realarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray, realarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertIntIntInt(intarray1, intarray2, intarray3, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, intarray3, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertIntIntLong(intarray1, intarray2, longarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint, Cint, Clonglong, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, longarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertIntRealLong(intarray, realarray, longarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertIntRealLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Cint, Cdouble, Clonglong, Ptr{Cint}, Ptr{Cint}), intarray, realarray, longarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertIntIntPtr(intarray1, intarray2, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, ptrarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertIntIntReal(intarray1, intarray2, realarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, realarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertIntPtrReal(intarray, ptrarray, realarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertIntPtrReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cint, Ptr{Cvoid}, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray, ptrarray, realarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint, Cint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, intarray3, ptrarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertIntIntIntReal(intarray1, intarray2, intarray3, realarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint, Cint, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, intarray3, realarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cvoid}, Cint, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray1, ptrarray, intarray2, realarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertLong(longarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertLong, libscip), Cvoid, (Ptr{Clonglong}, Clonglong, Ptr{Cint}, Ptr{Cint}), longarray, keyval, len, pos) +end + +function SCIPsortedvecInsertLongPtr(longarray, ptrarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Clonglong, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertLongPtrInt(longarray, ptrarray, intarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, intarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertLongPtrRealBool(longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Clonglong, Ptr{Cvoid}, Cdouble, UInt32, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, UInt32, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) + ccall((:SCIPsortedvecInsertLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cint, UInt32, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +end + +function SCIPsortedvecInsertLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray1, intarray2, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, UInt32, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, UInt32, UInt32, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) + ccall((:SCIPsortedvecInsertIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Cint, Ptr{Cvoid}, Cint, Cint, UInt32, UInt32, Ptr{Cint}, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +end + +function SCIPsortedvecInsertDownInd(indarray, indcomp, dataptr, keyval, len, pos) + ccall((:SCIPsortedvecInsertDownInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), indarray, indcomp, dataptr, keyval, len, pos) +end + +function SCIPsortedvecInsertDownPtr(ptrarray, ptrcomp, keyval, len, pos) + ccall((:SCIPsortedvecInsertDownPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), ptrarray, ptrcomp, keyval, len, pos) +end + +function SCIPsortedvecInsertDownPtrPtr(ptrarray1, ptrarray2, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, ptrcomp, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownPtrReal(ptrarray, realarray, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, ptrcomp, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownPtrInt(ptrarray, intarray, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray, ptrcomp, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownPtrBool(ptrarray, boolarray, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cvoid}, UInt32, Ptr{Cint}, Ptr{Cint}), ptrarray, boolarray, ptrcomp, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownPtrRealInt(ptrarray, realarray, intarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, intarray, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, UInt32, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, intarray, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, realarray, ptrcomp, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cint, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, UInt32, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Clonglong, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Clonglong, Cint, Cint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertDownReal(realarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cdouble, Ptr{Cint}, Ptr{Cint}), realarray, keyval, len, pos) +end + +function SCIPsortedvecInsertDownRealBoolPtr(realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cdouble, UInt32, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownRealPtr(realarray, ptrarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cdouble, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, ptrarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownRealPtrPtr(realarray, ptrarray1, ptrarray2, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, ptrarray1, ptrarray2, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownRealInt(realarray, intarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), realarray, intarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownRealIntInt(realarray, intarray1, intarray2, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cdouble, Cint, Cint, Ptr{Cint}, Ptr{Cint}), realarray, intarray1, intarray2, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownRealRealInt(realarray, realarray2, intarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cdouble, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), realarray, realarray2, intarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownRealIntLong(realarray, intarray, longarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cdouble, Cint, Clonglong, Ptr{Cint}, Ptr{Cint}), realarray, intarray, longarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownRealIntPtr(realarray, intarray, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cdouble, Cint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, intarray, ptrarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownRealRealPtr(realarray1, realarray2, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, ptrarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownRealRealPtrPtr(realarray1, realarray2, ptrarray1, ptrarray2, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownRealRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, ptrarray1, ptrarray2, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, keyval, field1val, field2val, intval, len, pos) + ccall((:SCIPsortedvecInsertDownRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray, keyval, field1val, field2val, intval, len, pos) +end + +function SCIPsortedvecInsertDownRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, keyval, field1val, field2val, intval1, intval2, len, pos) + ccall((:SCIPsortedvecInsertDownRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray1, intarray2, keyval, field1val, field2val, intval1, intval2, len, pos) +end + +function SCIPsortedvecInsertDownRealLongRealInt(realarray1, longarray, realarray3, intarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Cdouble, Clonglong, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), realarray1, longarray, realarray3, intarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownRealRealIntInt(realarray1, realarray2, intarray1, intarray2, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cdouble, Cdouble, Cint, Cint, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, intarray1, intarray2, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownRealRealRealInt(realarray1, realarray2, realarray3, intarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cdouble, Cdouble, Cdouble, Cint, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, intarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, ptrarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, UInt32, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) + ccall((:SCIPsortedvecInsertDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, UInt32, UInt32, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +end + +function SCIPsortedvecInsertDownInt(intarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertDownInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), intarray, keyval, len, pos) +end + +function SCIPsortedvecInsertDownIntInt(intarray1, intarray2, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownIntReal(intarray, realarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray, realarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownIntIntInt(intarray1, intarray2, intarray3, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, intarray3, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownIntIntLong(intarray1, intarray2, longarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint, Cint, Clonglong, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, longarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownIntIntPtr(intarray1, intarray2, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, ptrarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownIntIntReal(intarray1, intarray2, realarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, realarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownIntPtr(intarray, ptrarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), intarray, ptrarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint, Cint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, intarray3, ptrarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownIntIntIntReal(intarray1, intarray2, intarray3, realarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cint, Cint, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, intarray3, realarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cvoid}, Cint, Cdouble, Ptr{Cint}, Ptr{Cint}), intarray1, ptrarray, intarray2, realarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownLong(longarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertDownLong, libscip), Cvoid, (Ptr{Clonglong}, Clonglong, Ptr{Cint}, Ptr{Cint}), longarray, keyval, len, pos) +end + +function SCIPsortedvecInsertDownLongPtr(longarray, ptrarray, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Clonglong, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, keyval, field1val, len, pos) +end + +function SCIPsortedvecInsertDownLongPtrInt(longarray, ptrarray, intarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, intarray, keyval, field1val, field2val, len, pos) +end + +function SCIPsortedvecInsertDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Clonglong, Ptr{Cvoid}, Cdouble, UInt32, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, UInt32, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertDownLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cint, UInt32, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +end + +function SCIPsortedvecInsertDownLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray, keyval, field1val, field2val, field3val, len, pos) +end + +function SCIPsortedvecInsertDownLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray1, intarray2, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, UInt32, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, UInt32, UInt32, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) +end + +function SCIPsortedvecInsertDownIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) + ccall((:SCIPsortedvecInsertDownIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Cint, Ptr{Cvoid}, Cint, Cint, UInt32, UInt32, Ptr{Cint}, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +end + +function SCIPsortedvecDelPosInd(indarray, indcomp, dataptr, pos, len) + ccall((:SCIPsortedvecDelPosInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), indarray, indcomp, dataptr, pos, len) +end + +function SCIPsortedvecDelPosPtr(ptrarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrPtr(ptrarray1, ptrarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrReal(ptrarray, realarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrInt(ptrarray, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrBool(ptrarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrRealInt(ptrarray, realarray, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrRealRealInt(ptrarray, realarray1, realarray2, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrRealRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, intarray1, intarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosRealBoolPtr(realarray, boolarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosRealPtr(realarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosReal(realarray, pos, len) + ccall((:SCIPsortedvecDelPosReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Ptr{Cint}), realarray, pos, len) +end + +function SCIPsortedvecDelPosRealInt(realarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, intarray, pos, len) +end + +function SCIPsortedvecDelPosRealIntInt(realarray, intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosRealIntLong(realarray, intarray, longarray, pos, len) + ccall((:SCIPsortedvecDelPosRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint, Ptr{Cint}), realarray, intarray, longarray, pos, len) +end + +function SCIPsortedvecDelPosRealIntPtr(realarray, intarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, intarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosRealRealPtr(realarray1, realarray2, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, pos, len) + ccall((:SCIPsortedvecDelPosRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray, pos, len) +end + +function SCIPsortedvecDelPosRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosRealLongRealInt(realarray1, longarray, realarray3, intarray, pos, len) + ccall((:SCIPsortedvecDelPosRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray1, longarray, realarray3, intarray, pos, len) +end + +function SCIPsortedvecDelPosRealRealIntInt(realarray1, realarray2, intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), realarray1, realarray2, intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosRealRealRealInt(realarray1, realarray2, realarray3, intarray, pos, len) + ccall((:SCIPsortedvecDelPosRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, intarray, pos, len) +end + +function SCIPsortedvecDelPosRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosInt(intarray, pos, len) + ccall((:SCIPsortedvecDelPosInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}), intarray, pos, len) +end + +function SCIPsortedvecDelPosIntInt(intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosIntReal(intarray, realarray, pos, len) + ccall((:SCIPsortedvecDelPosIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray, realarray, pos, len) +end + +function SCIPsortedvecDelPosIntIntInt(intarray1, intarray2, intarray3, pos, len) + ccall((:SCIPsortedvecDelPosIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, pos, len) +end + +function SCIPsortedvecDelPosIntIntLong(intarray1, intarray2, longarray, pos, len) + ccall((:SCIPsortedvecDelPosIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint, Ptr{Cint}), intarray1, intarray2, longarray, pos, len) +end + +function SCIPsortedvecDelPosIntRealLong(intarray, realarray, longarray, pos, len) + ccall((:SCIPsortedvecDelPosIntRealLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Cint, Ptr{Cint}), intarray, realarray, longarray, pos, len) +end + +function SCIPsortedvecDelPosIntIntPtr(intarray1, intarray2, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosIntIntReal(intarray1, intarray2, realarray, pos, len) + ccall((:SCIPsortedvecDelPosIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray1, intarray2, realarray, pos, len) +end + +function SCIPsortedvecDelPosIntPtr(intarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosIntPtrReal(intarray, ptrarray, realarray, pos, len) + ccall((:SCIPsortedvecDelPosIntPtrReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray, ptrarray, realarray, pos, len) +end + +function SCIPsortedvecDelPosIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosIntIntIntReal(intarray1, intarray2, intarray3, realarray, pos, len) + ccall((:SCIPsortedvecDelPosIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, realarray, pos, len) +end + +function SCIPsortedvecDelPosIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, pos, len) + ccall((:SCIPsortedvecDelPosIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, realarray, pos, len) +end + +function SCIPsortedvecDelPosLong(longarray, pos, len) + ccall((:SCIPsortedvecDelPosLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Ptr{Cint}), longarray, pos, len) +end + +function SCIPsortedvecDelPosLongPtr(longarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), longarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosLongPtrInt(longarray, ptrarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray, intarray, pos, len) +end + +function SCIPsortedvecDelPosLongPtrRealBool(longarray, ptrarray, realarray, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, pos, len) +end + +function SCIPsortedvecDelPosLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, pos, len) +end + +function SCIPsortedvecDelPosLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, pos, len) +end + +function SCIPsortedvecDelPosLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray, pos, len) +end + +function SCIPsortedvecDelPosLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) +end + +function SCIPsortedvecDelPosPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) + ccall((:SCIPsortedvecDelPosIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) +end + +function SCIPsortedvecDelPosDownInd(indarray, indcomp, dataptr, pos, len) + ccall((:SCIPsortedvecDelPosDownInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), indarray, indcomp, dataptr, pos, len) +end + +function SCIPsortedvecDelPosDownPtr(ptrarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrPtr(ptrarray1, ptrarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrReal(ptrarray, realarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrInt(ptrarray, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrBool(ptrarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrIntInt(ptrarray, intarray1, intarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrRealInt(ptrarray, realarray, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrPtrInt(ptrarray1, ptrarray2, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrPtrReal(ptrarray1, ptrarray2, realarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrPtrIntInt(ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtrIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, intarray1, intarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrRealIntInt(ptrarray, realarray, intarray1, intarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrRealIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, intarray1, intarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrPtrRealInt(ptrarray1, ptrarray2, realarray, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtrRealInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrPtrLongInt(ptrarray1, ptrarray2, longarray, intarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtrLongInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownPtrPtrLongIntInt(ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtrLongIntInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Clonglong}, Ptr{Cint}, Ptr{Cint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, longarray, intarray1, intarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownReal(realarray, pos, len) + ccall((:SCIPsortedvecDelPosDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Ptr{Cint}), realarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealBoolPtr(realarray, boolarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealPtr(realarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealInt(realarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, intarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealIntInt(realarray, intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosDownRealIntLong(realarray, intarray, longarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint, Ptr{Cint}), realarray, intarray, longarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealIntPtr(realarray, intarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, intarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealRealInt(realarray1, realarray2, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray1, realarray2, intarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealRealPtr(realarray1, realarray2, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealRealPtrPtr(realarray1, realarray2, ptrarray1, ptrarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, ptrarray1, ptrarray2, pos, len) +end + +function SCIPsortedvecDelPosDownRealPtrPtr(realarray, ptrarray1, ptrarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, pos, len) +end + +function SCIPsortedvecDelPosDownRealPtrPtrInt(realarray, ptrarray1, ptrarray2, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealPtrPtrInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealPtrPtrIntInt(realarray, ptrarray1, ptrarray2, intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownRealPtrPtrIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosDownRealLongRealInt(realarray1, longarray, realarray3, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealLongRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Clonglong}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray1, longarray, realarray3, intarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealRealIntInt(realarray1, realarray2, intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), realarray1, realarray2, intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosDownRealRealRealInt(realarray1, realarray2, realarray3, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, intarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealRealRealPtr(realarray1, realarray2, realarray3, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownInt(intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}), intarray, pos, len) +end + +function SCIPsortedvecDelPosDownIntInt(intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosDownIntReal(intarray, realarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray, realarray, pos, len) +end + +function SCIPsortedvecDelPosDownIntIntInt(intarray1, intarray2, intarray3, pos, len) + ccall((:SCIPsortedvecDelPosDownIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, pos, len) +end + +function SCIPsortedvecDelPosDownIntIntLong(intarray1, intarray2, longarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint, Ptr{Cint}), intarray1, intarray2, longarray, pos, len) +end + +function SCIPsortedvecDelPosDownIntIntPtr(intarray1, intarray2, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownIntIntReal(intarray1, intarray2, realarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray1, intarray2, realarray, pos, len) +end + +function SCIPsortedvecDelPosDownIntPtr(intarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownIntIntIntPtr(intarray1, intarray2, intarray3, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownIntIntIntReal(intarray1, intarray2, intarray3, realarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, realarray, pos, len) +end + +function SCIPsortedvecDelPosDownIntPtrIntReal(intarray1, ptrarray, intarray2, realarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntPtrIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, realarray, pos, len) +end + +function SCIPsortedvecDelPosDownLong(longarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Ptr{Cint}), longarray, pos, len) +end + +function SCIPsortedvecDelPosDownLongPtr(longarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), longarray, ptrarray, pos, len) +end + +function SCIPsortedvecDelPosDownLongPtrInt(longarray, ptrarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray, intarray, pos, len) +end + +function SCIPsortedvecDelPosDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{UInt32}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, pos, len) +end + +function SCIPsortedvecDelPosDownLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{UInt32}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, pos, len) +end + +function SCIPsortedvecDelPosDownLongPtrRealRealIntBool(longarray, ptrarray, realarray, realarray2, intarray, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrRealRealIntBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{UInt32}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, pos, len) +end + +function SCIPsortedvecDelPosDownLongPtrPtrInt(longarray, ptrarray1, ptrarray2, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray, pos, len) +end + +function SCIPsortedvecDelPosDownLongPtrPtrIntInt(longarray, ptrarray1, ptrarray2, intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrPtrIntInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, intarray1, intarray2, pos, len) +end + +function SCIPsortedvecDelPosDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{UInt32}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) +end + +function SCIPsortedvecDelPosDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, pos, len) +end + +function SCIPsortedvecDelPosDownIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt32}, Ptr{UInt32}, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) +end + +function SCIPsortedvecFindInd(indarray, indcomp, dataptr, val, len, pos) + ccall((:SCIPsortedvecFindInd, libscip), UInt32, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}), indarray, indcomp, dataptr, val, len, pos) +end + +function SCIPsortedvecFindPtr(ptrarray, ptrcomp, val, len, pos) + ccall((:SCIPsortedvecFindPtr, libscip), UInt32, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, val, len, pos) +end + +function SCIPsortedvecFindReal(realarray, val, len, pos) + ccall((:SCIPsortedvecFindReal, libscip), UInt32, (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, val, len, pos) +end + +function SCIPsortedvecFindInt(intarray, val, len, pos) + ccall((:SCIPsortedvecFindInt, libscip), UInt32, (Ptr{Cint}, Cint, Cint, Ptr{Cint}), intarray, val, len, pos) +end + +function SCIPsortedvecFindLong(longarray, val, len, pos) + ccall((:SCIPsortedvecFindLong, libscip), UInt32, (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), longarray, val, len, pos) +end + +function SCIPsortedvecFindDownInd(indarray, indcomp, dataptr, val, len, pos) + ccall((:SCIPsortedvecFindDownInd, libscip), UInt32, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}), indarray, indcomp, dataptr, val, len, pos) +end + +function SCIPsortedvecFindDownPtr(ptrarray, ptrcomp, val, len, pos) + ccall((:SCIPsortedvecFindDownPtr, libscip), UInt32, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, val, len, pos) +end + +function SCIPsortedvecFindDownReal(realarray, val, len, pos) + ccall((:SCIPsortedvecFindDownReal, libscip), UInt32, (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, val, len, pos) +end + +function SCIPsortedvecFindDownInt(intarray, val, len, pos) + ccall((:SCIPsortedvecFindDownInt, libscip), UInt32, (Ptr{Cint}, Cint, Cint, Ptr{Cint}), intarray, val, len, pos) +end + +function SCIPsortedvecFindDownLong(longarray, val, len, pos) + ccall((:SCIPsortedvecFindDownLong, libscip), UInt32, (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), longarray, val, len, pos) +end diff --git a/src/wrapper/pub_nlp.jl b/src/wrapper/pub_nlp.jl new file mode 100644 index 00000000..b5ca1dbe --- /dev/null +++ b/src/wrapper/pub_nlp.jl @@ -0,0 +1,99 @@ +# Julia wrapper for header: /usr/include/scip/pub_nlp.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPexprtreeGetVars(tree) + ccall((:SCIPexprtreeGetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_EXPRTREE},), tree) +end + +function SCIPexprtreeSetVars(tree, nvars, vars) + ccall((:SCIPexprtreeSetVars, libscip), SCIP_RETCODE, (Ptr{SCIP_EXPRTREE}, Cint, Ptr{Ptr{SCIP_VAR}}), tree, nvars, vars) +end + +function SCIPexprtreeAddVars(tree, nvars, vars) + ccall((:SCIPexprtreeAddVars, libscip), SCIP_RETCODE, (Ptr{SCIP_EXPRTREE}, Cint, Ptr{Ptr{SCIP_VAR}}), tree, nvars, vars) +end + +function SCIPexprtreePrintWithNames(tree, messagehdlr, file) + ccall((:SCIPexprtreePrintWithNames, libscip), SCIP_RETCODE, (Ptr{SCIP_EXPRTREE}, Ptr{SCIP_MESSAGEHDLR}, Ptr{FILE}), tree, messagehdlr, file) +end + +function SCIPexprtreeFindVar(tree, var) + ccall((:SCIPexprtreeFindVar, libscip), Cint, (Ptr{SCIP_EXPRTREE}, Ptr{SCIP_VAR}), tree, var) +end + +function SCIPnlrowGetConstant(nlrow) + ccall((:SCIPnlrowGetConstant, libscip), Cdouble, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetNLinearVars(nlrow) + ccall((:SCIPnlrowGetNLinearVars, libscip), Cint, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetLinearVars(nlrow) + ccall((:SCIPnlrowGetLinearVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetLinearCoefs(nlrow) + ccall((:SCIPnlrowGetLinearCoefs, libscip), Ptr{Cdouble}, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetNQuadVars(nlrow) + ccall((:SCIPnlrowGetNQuadVars, libscip), Cint, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetQuadVars(nlrow) + ccall((:SCIPnlrowGetQuadVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowSearchQuadVar(nlrow, var) + ccall((:SCIPnlrowSearchQuadVar, libscip), Cint, (Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}), nlrow, var) +end + +function SCIPnlrowGetNQuadElems(nlrow) + ccall((:SCIPnlrowGetNQuadElems, libscip), Cint, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetQuadElems(nlrow) + ccall((:SCIPnlrowGetQuadElems, libscip), Ptr{SCIP_QUADELEM}, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetQuadData(nlrow, nquadvars, quadvars, nquadelems, quadelems) + ccall((:SCIPnlrowGetQuadData, libscip), Cvoid, (Ptr{SCIP_NLROW}, Ptr{Cint}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Ptr{SCIP_QUADELEM}}), nlrow, nquadvars, quadvars, nquadelems, quadelems) +end + +function SCIPnlrowGetExprtree(nlrow) + ccall((:SCIPnlrowGetExprtree, libscip), Ptr{SCIP_EXPRTREE}, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetLhs(nlrow) + ccall((:SCIPnlrowGetLhs, libscip), Cdouble, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetRhs(nlrow) + ccall((:SCIPnlrowGetRhs, libscip), Cdouble, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetCurvature(nlrow) + ccall((:SCIPnlrowGetCurvature, libscip), SCIP_EXPRCURV, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowSetCurvature(nlrow, curvature) + ccall((:SCIPnlrowSetCurvature, libscip), Cvoid, (Ptr{SCIP_NLROW}, SCIP_EXPRCURV), nlrow, curvature) +end + +function SCIPnlrowGetName(nlrow) + ccall((:SCIPnlrowGetName, libscip), Cstring, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetNLPPos(nlrow) + ccall((:SCIPnlrowGetNLPPos, libscip), Cint, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowIsInNLP(nlrow) + ccall((:SCIPnlrowIsInNLP, libscip), UInt32, (Ptr{SCIP_NLROW},), nlrow) +end + +function SCIPnlrowGetDualsol(nlrow) + ccall((:SCIPnlrowGetDualsol, libscip), Cdouble, (Ptr{SCIP_NLROW},), nlrow) +end diff --git a/src/wrapper/pub_nodesel.jl b/src/wrapper/pub_nodesel.jl new file mode 100644 index 00000000..aa46e729 --- /dev/null +++ b/src/wrapper/pub_nodesel.jl @@ -0,0 +1,39 @@ +# Julia wrapper for header: /usr/include/scip/pub_nodesel.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPnodeselGetName(nodesel) + ccall((:SCIPnodeselGetName, libscip), Cstring, (Ptr{SCIP_NODESEL},), nodesel) +end + +function SCIPnodeselGetDesc(nodesel) + ccall((:SCIPnodeselGetDesc, libscip), Cstring, (Ptr{SCIP_NODESEL},), nodesel) +end + +function SCIPnodeselGetStdPriority(nodesel) + ccall((:SCIPnodeselGetStdPriority, libscip), Cint, (Ptr{SCIP_NODESEL},), nodesel) +end + +function SCIPnodeselGetMemsavePriority(nodesel) + ccall((:SCIPnodeselGetMemsavePriority, libscip), Cint, (Ptr{SCIP_NODESEL},), nodesel) +end + +function SCIPnodeselGetData(nodesel) + ccall((:SCIPnodeselGetData, libscip), Ptr{SCIP_NODESELDATA}, (Ptr{SCIP_NODESEL},), nodesel) +end + +function SCIPnodeselSetData(nodesel, nodeseldata) + ccall((:SCIPnodeselSetData, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{SCIP_NODESELDATA}), nodesel, nodeseldata) +end + +function SCIPnodeselIsInitialized(nodesel) + ccall((:SCIPnodeselIsInitialized, libscip), UInt32, (Ptr{SCIP_NODESEL},), nodesel) +end + +function SCIPnodeselGetSetupTime(nodesel) + ccall((:SCIPnodeselGetSetupTime, libscip), Cdouble, (Ptr{SCIP_NODESEL},), nodesel) +end + +function SCIPnodeselGetTime(nodesel) + ccall((:SCIPnodeselGetTime, libscip), Cdouble, (Ptr{SCIP_NODESEL},), nodesel) +end diff --git a/src/wrapper/pub_paramset.jl b/src/wrapper/pub_paramset.jl new file mode 100644 index 00000000..c7912460 --- /dev/null +++ b/src/wrapper/pub_paramset.jl @@ -0,0 +1,111 @@ +# Julia wrapper for header: /usr/include/scip/pub_paramset.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPparamGetType(param) + ccall((:SCIPparamGetType, libscip), SCIP_PARAMTYPE, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetName(param) + ccall((:SCIPparamGetName, libscip), Cstring, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetDesc(param) + ccall((:SCIPparamGetDesc, libscip), Cstring, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetData(param) + ccall((:SCIPparamGetData, libscip), Ptr{SCIP_PARAMDATA}, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamIsAdvanced(param) + ccall((:SCIPparamIsAdvanced, libscip), UInt32, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamIsFixed(param) + ccall((:SCIPparamIsFixed, libscip), UInt32, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamSetFixed(param, fixed) + ccall((:SCIPparamSetFixed, libscip), Cvoid, (Ptr{SCIP_PARAM}, UInt32), param, fixed) +end + +function SCIPparamGetBool(param) + ccall((:SCIPparamGetBool, libscip), UInt32, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetBoolDefault(param) + ccall((:SCIPparamGetBoolDefault, libscip), UInt32, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetInt(param) + ccall((:SCIPparamGetInt, libscip), Cint, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetIntMin(param) + ccall((:SCIPparamGetIntMin, libscip), Cint, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetIntMax(param) + ccall((:SCIPparamGetIntMax, libscip), Cint, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetIntDefault(param) + ccall((:SCIPparamGetIntDefault, libscip), Cint, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetLongint(param) + ccall((:SCIPparamGetLongint, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetLongintMin(param) + ccall((:SCIPparamGetLongintMin, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetLongintMax(param) + ccall((:SCIPparamGetLongintMax, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetLongintDefault(param) + ccall((:SCIPparamGetLongintDefault, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetReal(param) + ccall((:SCIPparamGetReal, libscip), Cdouble, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetRealMin(param) + ccall((:SCIPparamGetRealMin, libscip), Cdouble, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetRealMax(param) + ccall((:SCIPparamGetRealMax, libscip), Cdouble, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetRealDefault(param) + ccall((:SCIPparamGetRealDefault, libscip), Cdouble, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetChar(param) + ccall((:SCIPparamGetChar, libscip), UInt8, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetCharAllowedValues(param) + ccall((:SCIPparamGetCharAllowedValues, libscip), Cstring, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetCharDefault(param) + ccall((:SCIPparamGetCharDefault, libscip), UInt8, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetString(param) + ccall((:SCIPparamGetString, libscip), Cstring, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamGetStringDefault(param) + ccall((:SCIPparamGetStringDefault, libscip), Cstring, (Ptr{SCIP_PARAM},), param) +end + +function SCIPparamIsDefault(param) + ccall((:SCIPparamIsDefault, libscip), UInt32, (Ptr{SCIP_PARAM},), param) +end diff --git a/src/wrapper/pub_presol.jl b/src/wrapper/pub_presol.jl new file mode 100644 index 00000000..fcb78a7e --- /dev/null +++ b/src/wrapper/pub_presol.jl @@ -0,0 +1,99 @@ +# Julia wrapper for header: /usr/include/scip/pub_presol.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPpresolComp(elem1, elem2) + ccall((:SCIPpresolComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPpresolCompName(elem1, elem2) + ccall((:SCIPpresolCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPpresolGetData(presol) + ccall((:SCIPpresolGetData, libscip), Ptr{SCIP_PRESOLDATA}, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolSetData(presol, presoldata) + ccall((:SCIPpresolSetData, libscip), Cvoid, (Ptr{SCIP_PRESOL}, Ptr{SCIP_PRESOLDATA}), presol, presoldata) +end + +function SCIPpresolGetName(presol) + ccall((:SCIPpresolGetName, libscip), Cstring, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetDesc(presol) + ccall((:SCIPpresolGetDesc, libscip), Cstring, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetPriority(presol) + ccall((:SCIPpresolGetPriority, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetMaxrounds(presol) + ccall((:SCIPpresolGetMaxrounds, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetTiming(presol) + ccall((:SCIPpresolGetTiming, libscip), SCIP_PRESOLTIMING, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolSetTiming(presol, timing) + ccall((:SCIPpresolSetTiming, libscip), Cvoid, (Ptr{SCIP_PRESOL}, SCIP_PRESOLTIMING), presol, timing) +end + +function SCIPpresolIsInitialized(presol) + ccall((:SCIPpresolIsInitialized, libscip), UInt32, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetSetupTime(presol) + ccall((:SCIPpresolGetSetupTime, libscip), Cdouble, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetTime(presol) + ccall((:SCIPpresolGetTime, libscip), Cdouble, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNFixedVars(presol) + ccall((:SCIPpresolGetNFixedVars, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNAggrVars(presol) + ccall((:SCIPpresolGetNAggrVars, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNChgVarTypes(presol) + ccall((:SCIPpresolGetNChgVarTypes, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNChgBds(presol) + ccall((:SCIPpresolGetNChgBds, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNAddHoles(presol) + ccall((:SCIPpresolGetNAddHoles, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNDelConss(presol) + ccall((:SCIPpresolGetNDelConss, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNAddConss(presol) + ccall((:SCIPpresolGetNAddConss, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNUpgdConss(presol) + ccall((:SCIPpresolGetNUpgdConss, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNChgCoefs(presol) + ccall((:SCIPpresolGetNChgCoefs, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNChgSides(presol) + ccall((:SCIPpresolGetNChgSides, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end + +function SCIPpresolGetNCalls(presol) + ccall((:SCIPpresolGetNCalls, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) +end diff --git a/src/wrapper/pub_pricer.jl b/src/wrapper/pub_pricer.jl new file mode 100644 index 00000000..533392b1 --- /dev/null +++ b/src/wrapper/pub_pricer.jl @@ -0,0 +1,59 @@ +# Julia wrapper for header: /usr/include/scip/pub_pricer.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPpricerComp(elem1, elem2) + ccall((:SCIPpricerComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPpricerCompName(elem1, elem2) + ccall((:SCIPpricerCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPpricerGetData(pricer) + ccall((:SCIPpricerGetData, libscip), Ptr{SCIP_PRICERDATA}, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerSetData(pricer, pricerdata) + ccall((:SCIPpricerSetData, libscip), Cvoid, (Ptr{SCIP_PRICER}, Ptr{SCIP_PRICERDATA}), pricer, pricerdata) +end + +function SCIPpricerGetName(pricer) + ccall((:SCIPpricerGetName, libscip), Cstring, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerGetDesc(pricer) + ccall((:SCIPpricerGetDesc, libscip), Cstring, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerGetPriority(pricer) + ccall((:SCIPpricerGetPriority, libscip), Cint, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerGetNCalls(pricer) + ccall((:SCIPpricerGetNCalls, libscip), Cint, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerGetNVarsFound(pricer) + ccall((:SCIPpricerGetNVarsFound, libscip), Cint, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerGetSetupTime(pricer) + ccall((:SCIPpricerGetSetupTime, libscip), Cdouble, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerGetTime(pricer) + ccall((:SCIPpricerGetTime, libscip), Cdouble, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerIsActive(pricer) + ccall((:SCIPpricerIsActive, libscip), UInt32, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerIsDelayed(pricer) + ccall((:SCIPpricerIsDelayed, libscip), UInt32, (Ptr{SCIP_PRICER},), pricer) +end + +function SCIPpricerIsInitialized(pricer) + ccall((:SCIPpricerIsInitialized, libscip), UInt32, (Ptr{SCIP_PRICER},), pricer) +end diff --git a/src/wrapper/pub_prop.jl b/src/wrapper/pub_prop.jl new file mode 100644 index 00000000..716ed10e --- /dev/null +++ b/src/wrapper/pub_prop.jl @@ -0,0 +1,155 @@ +# Julia wrapper for header: /usr/include/scip/pub_prop.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPpropComp(elem1, elem2) + ccall((:SCIPpropComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPpropCompPresol(elem1, elem2) + ccall((:SCIPpropCompPresol, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPpropCompName(elem1, elem2) + ccall((:SCIPpropCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPpropGetData(prop) + ccall((:SCIPpropGetData, libscip), Ptr{SCIP_PROPDATA}, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropSetData(prop, propdata) + ccall((:SCIPpropSetData, libscip), Cvoid, (Ptr{SCIP_PROP}, Ptr{SCIP_PROPDATA}), prop, propdata) +end + +function SCIPpropGetName(prop) + ccall((:SCIPpropGetName, libscip), Cstring, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetDesc(prop) + ccall((:SCIPpropGetDesc, libscip), Cstring, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetPriority(prop) + ccall((:SCIPpropGetPriority, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetPresolPriority(prop) + ccall((:SCIPpropGetPresolPriority, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetFreq(prop) + ccall((:SCIPpropGetFreq, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetSetupTime(prop) + ccall((:SCIPpropGetSetupTime, libscip), Cdouble, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropSetFreq(prop, freq) + ccall((:SCIPpropSetFreq, libscip), Cvoid, (Ptr{SCIP_PROP}, Cint), prop, freq) +end + +function SCIPpropGetTime(prop) + ccall((:SCIPpropGetTime, libscip), Cdouble, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetStrongBranchPropTime(prop) + ccall((:SCIPpropGetStrongBranchPropTime, libscip), Cdouble, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetRespropTime(prop) + ccall((:SCIPpropGetRespropTime, libscip), Cdouble, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetPresolTime(prop) + ccall((:SCIPpropGetPresolTime, libscip), Cdouble, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNCalls(prop) + ccall((:SCIPpropGetNCalls, libscip), Clonglong, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNRespropCalls(prop) + ccall((:SCIPpropGetNRespropCalls, libscip), Clonglong, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNCutoffs(prop) + ccall((:SCIPpropGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNDomredsFound(prop) + ccall((:SCIPpropGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropIsDelayed(prop) + ccall((:SCIPpropIsDelayed, libscip), UInt32, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropWasDelayed(prop) + ccall((:SCIPpropWasDelayed, libscip), UInt32, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropIsInitialized(prop) + ccall((:SCIPpropIsInitialized, libscip), UInt32, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNFixedVars(prop) + ccall((:SCIPpropGetNFixedVars, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNAggrVars(prop) + ccall((:SCIPpropGetNAggrVars, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNChgVarTypes(prop) + ccall((:SCIPpropGetNChgVarTypes, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNChgBds(prop) + ccall((:SCIPpropGetNChgBds, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNAddHoles(prop) + ccall((:SCIPpropGetNAddHoles, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNDelConss(prop) + ccall((:SCIPpropGetNDelConss, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNAddConss(prop) + ccall((:SCIPpropGetNAddConss, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNUpgdConss(prop) + ccall((:SCIPpropGetNUpgdConss, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNChgCoefs(prop) + ccall((:SCIPpropGetNChgCoefs, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNChgSides(prop) + ccall((:SCIPpropGetNChgSides, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetNPresolCalls(prop) + ccall((:SCIPpropGetNPresolCalls, libscip), Cint, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetTimingmask(prop) + ccall((:SCIPpropGetTimingmask, libscip), SCIP_PROPTIMING, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropDoesPresolve(prop) + ccall((:SCIPpropDoesPresolve, libscip), UInt32, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropGetPresolTiming(prop) + ccall((:SCIPpropGetPresolTiming, libscip), SCIP_PRESOLTIMING, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropSetPresolTiming(prop, presoltiming) + ccall((:SCIPpropSetPresolTiming, libscip), Cvoid, (Ptr{SCIP_PROP}, SCIP_PRESOLTIMING), prop, presoltiming) +end diff --git a/src/wrapper/pub_reader.jl b/src/wrapper/pub_reader.jl new file mode 100644 index 00000000..ab4869ea --- /dev/null +++ b/src/wrapper/pub_reader.jl @@ -0,0 +1,31 @@ +# Julia wrapper for header: /usr/include/scip/pub_reader.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPreaderGetData(reader) + ccall((:SCIPreaderGetData, libscip), Ptr{SCIP_READERDATA}, (Ptr{SCIP_READER},), reader) +end + +function SCIPreaderSetData(reader, readerdata) + ccall((:SCIPreaderSetData, libscip), Cvoid, (Ptr{SCIP_READER}, Ptr{SCIP_READERDATA}), reader, readerdata) +end + +function SCIPreaderGetName(reader) + ccall((:SCIPreaderGetName, libscip), Cstring, (Ptr{SCIP_READER},), reader) +end + +function SCIPreaderGetDesc(reader) + ccall((:SCIPreaderGetDesc, libscip), Cstring, (Ptr{SCIP_READER},), reader) +end + +function SCIPreaderGetExtension(reader) + ccall((:SCIPreaderGetExtension, libscip), Cstring, (Ptr{SCIP_READER},), reader) +end + +function SCIPreaderCanRead(reader) + ccall((:SCIPreaderCanRead, libscip), UInt32, (Ptr{SCIP_READER},), reader) +end + +function SCIPreaderCanWrite(reader) + ccall((:SCIPreaderCanWrite, libscip), UInt32, (Ptr{SCIP_READER},), reader) +end diff --git a/src/wrapper/pub_relax.jl b/src/wrapper/pub_relax.jl new file mode 100644 index 00000000..514fa211 --- /dev/null +++ b/src/wrapper/pub_relax.jl @@ -0,0 +1,55 @@ +# Julia wrapper for header: /usr/include/scip/pub_relax.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPrelaxComp(elem1, elem2) + ccall((:SCIPrelaxComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPrelaxCompName(elem1, elem2) + ccall((:SCIPrelaxCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPrelaxGetData(relax) + ccall((:SCIPrelaxGetData, libscip), Ptr{SCIP_RELAXDATA}, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxSetData(relax, relaxdata) + ccall((:SCIPrelaxSetData, libscip), Cvoid, (Ptr{SCIP_RELAX}, Ptr{SCIP_RELAXDATA}), relax, relaxdata) +end + +function SCIPrelaxGetName(relax) + ccall((:SCIPrelaxGetName, libscip), Cstring, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxGetDesc(relax) + ccall((:SCIPrelaxGetDesc, libscip), Cstring, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxGetPriority(relax) + ccall((:SCIPrelaxGetPriority, libscip), Cint, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxGetFreq(relax) + ccall((:SCIPrelaxGetFreq, libscip), Cint, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxGetSetupTime(relax) + ccall((:SCIPrelaxGetSetupTime, libscip), Cdouble, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxGetTime(relax) + ccall((:SCIPrelaxGetTime, libscip), Cdouble, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxGetNCalls(relax) + ccall((:SCIPrelaxGetNCalls, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxIsInitialized(relax) + ccall((:SCIPrelaxIsInitialized, libscip), UInt32, (Ptr{SCIP_RELAX},), relax) +end + +function SCIPrelaxMarkUnsolved(relax) + ccall((:SCIPrelaxMarkUnsolved, libscip), Cvoid, (Ptr{SCIP_RELAX},), relax) +end diff --git a/src/wrapper/pub_reopt.jl b/src/wrapper/pub_reopt.jl new file mode 100644 index 00000000..1f55a80d --- /dev/null +++ b/src/wrapper/pub_reopt.jl @@ -0,0 +1,91 @@ +# Julia wrapper for header: /usr/include/scip/pub_reopt.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPreoptnodeGetNVars(reoptnode) + ccall((:SCIPreoptnodeGetNVars, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) +end + +function SCIPreoptnodeGetNConss(reoptnode) + ccall((:SCIPreoptnodeGetNConss, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) +end + +function SCIPreoptnodeGetNDualBoundChgs(reoptnode) + ccall((:SCIPreoptnodeGetNDualBoundChgs, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) +end + +function SCIPreoptnodeGetNChildren(reoptnode) + ccall((:SCIPreoptnodeGetNChildren, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) +end + +function SCIPreoptnodeGetLowerbound(reoptnode) + ccall((:SCIPreoptnodeGetLowerbound, libscip), Cdouble, (Ptr{SCIP_REOPTNODE},), reoptnode) +end + +function SCIPreoptnodeGetType(reoptnode) + ccall((:SCIPreoptnodeGetType, libscip), SCIP_REOPTTYPE, (Ptr{SCIP_REOPTNODE},), reoptnode) +end + +function SCIPreoptnodeGetSplitCons(reoptnode, vars, vals, constype, conssize, nvars) + ccall((:SCIPreoptnodeGetSplitCons, libscip), Cvoid, (Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{REOPT_CONSTYPE}, Cint, Ptr{Cint}), reoptnode, vars, vals, constype, conssize, nvars) +end + +function SCIPreoptnodeGetConss(reoptnode, vars, bounds, boundtypes, mem, nconss, nvars) + ccall((:SCIPreoptnodeGetConss, libscip), Cvoid, (Ptr{SCIP_REOPTNODE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{SCIP_BOUNDTYPE}}, Cint, Ptr{Cint}, Ptr{Cint}), reoptnode, vars, bounds, boundtypes, mem, nconss, nvars) +end + +function SCIPreoptnodeSetParentID(reoptnode, parentid) + ccall((:SCIPreoptnodeSetParentID, libscip), Cvoid, (Ptr{SCIP_REOPTNODE}, UInt32), reoptnode, parentid) +end + +function SCIPreoptGetNRestartsGlobal(reopt) + ccall((:SCIPreoptGetNRestartsGlobal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNRestartsLocal(reopt) + ccall((:SCIPreoptGetNRestartsLocal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNTotalRestartsLocal(reopt) + ccall((:SCIPreoptGetNTotalRestartsLocal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetFirstRestarts(reopt) + ccall((:SCIPreoptGetFirstRestarts, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetLastRestarts(reopt) + ccall((:SCIPreoptGetLastRestarts, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNFeasNodes(reopt) + ccall((:SCIPreoptGetNFeasNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNTotalFeasNodes(reopt) + ccall((:SCIPreoptGetNTotalFeasNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNPrunedNodes(reopt) + ccall((:SCIPreoptGetNPrunedNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNTotalPrunedNodes(reopt) + ccall((:SCIPreoptGetNTotalPrunedNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNCutoffReoptnodes(reopt) + ccall((:SCIPreoptGetNCutoffReoptnodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNTotalCutoffReoptnodes(reopt) + ccall((:SCIPreoptGetNTotalCutoffReoptnodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNInfNodes(reopt) + ccall((:SCIPreoptGetNInfNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end + +function SCIPreoptGetNTotalInfNodes(reopt) + ccall((:SCIPreoptGetNTotalInfNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) +end diff --git a/src/wrapper/pub_sepa.jl b/src/wrapper/pub_sepa.jl new file mode 100644 index 00000000..e852d352 --- /dev/null +++ b/src/wrapper/pub_sepa.jl @@ -0,0 +1,103 @@ +# Julia wrapper for header: /usr/include/scip/pub_sepa.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPsepaComp(elem1, elem2) + ccall((:SCIPsepaComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPsepaCompName(elem1, elem2) + ccall((:SCIPsepaCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPsepaGetData(sepa) + ccall((:SCIPsepaGetData, libscip), Ptr{SCIP_SEPADATA}, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaSetData(sepa, sepadata) + ccall((:SCIPsepaSetData, libscip), Cvoid, (Ptr{SCIP_SEPA}, Ptr{SCIP_SEPADATA}), sepa, sepadata) +end + +function SCIPsepaGetName(sepa) + ccall((:SCIPsepaGetName, libscip), Cstring, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetDesc(sepa) + ccall((:SCIPsepaGetDesc, libscip), Cstring, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetPriority(sepa) + ccall((:SCIPsepaGetPriority, libscip), Cint, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetFreq(sepa) + ccall((:SCIPsepaGetFreq, libscip), Cint, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaSetFreq(sepa, freq) + ccall((:SCIPsepaSetFreq, libscip), Cvoid, (Ptr{SCIP_SEPA}, Cint), sepa, freq) +end + +function SCIPsepaGetMaxbounddist(sepa) + ccall((:SCIPsepaGetMaxbounddist, libscip), Cdouble, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaUsesSubscip(sepa) + ccall((:SCIPsepaUsesSubscip, libscip), UInt32, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetSetupTime(sepa) + ccall((:SCIPsepaGetSetupTime, libscip), Cdouble, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetTime(sepa) + ccall((:SCIPsepaGetTime, libscip), Cdouble, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCalls(sepa) + ccall((:SCIPsepaGetNCalls, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCallsAtNode(sepa) + ccall((:SCIPsepaGetNCallsAtNode, libscip), Cint, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCutoffs(sepa) + ccall((:SCIPsepaGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCutsFound(sepa) + ccall((:SCIPsepaGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCutsApplied(sepa) + ccall((:SCIPsepaGetNCutsApplied, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCutsFoundAtNode(sepa) + ccall((:SCIPsepaGetNCutsFoundAtNode, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNConssFound(sepa) + ccall((:SCIPsepaGetNConssFound, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNDomredsFound(sepa) + ccall((:SCIPsepaGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaIsDelayed(sepa) + ccall((:SCIPsepaIsDelayed, libscip), UInt32, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaWasLPDelayed(sepa) + ccall((:SCIPsepaWasLPDelayed, libscip), UInt32, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaWasSolDelayed(sepa) + ccall((:SCIPsepaWasSolDelayed, libscip), UInt32, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaIsInitialized(sepa) + ccall((:SCIPsepaIsInitialized, libscip), UInt32, (Ptr{SCIP_SEPA},), sepa) +end diff --git a/src/wrapper/pub_sol.jl b/src/wrapper/pub_sol.jl new file mode 100644 index 00000000..efaeda8c --- /dev/null +++ b/src/wrapper/pub_sol.jl @@ -0,0 +1,75 @@ +# Julia wrapper for header: /usr/include/scip/pub_sol.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPsolGetOrigin(sol) + ccall((:SCIPsolGetOrigin, libscip), SCIP_SOLORIGIN, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolIsOriginal(sol) + ccall((:SCIPsolIsOriginal, libscip), UInt32, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolIsPartial(sol) + ccall((:SCIPsolIsPartial, libscip), UInt32, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetOrigObj(sol) + ccall((:SCIPsolGetOrigObj, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetTime(sol) + ccall((:SCIPsolGetTime, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetRunnum(sol) + ccall((:SCIPsolGetRunnum, libscip), Cint, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetNodenum(sol) + ccall((:SCIPsolGetNodenum, libscip), Clonglong, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetDepth(sol) + ccall((:SCIPsolGetDepth, libscip), Cint, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetHeur(sol) + ccall((:SCIPsolGetHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolSetHeur(sol, heur) + ccall((:SCIPsolSetHeur, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}), sol, heur) +end + +function SCIPsolGetIndex(sol) + ccall((:SCIPsolGetIndex, libscip), Cint, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetAbsBoundViolation(sol) + ccall((:SCIPsolGetAbsBoundViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetRelBoundViolation(sol) + ccall((:SCIPsolGetRelBoundViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetAbsIntegralityViolation(sol) + ccall((:SCIPsolGetAbsIntegralityViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetAbsLPRowViolation(sol) + ccall((:SCIPsolGetAbsLPRowViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetRelLPRowViolation(sol) + ccall((:SCIPsolGetRelLPRowViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetAbsConsViolation(sol) + ccall((:SCIPsolGetAbsConsViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end + +function SCIPsolGetRelConsViolation(sol) + ccall((:SCIPsolGetRelConsViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) +end diff --git a/src/wrapper/pub_table.jl b/src/wrapper/pub_table.jl new file mode 100644 index 00000000..3882391b --- /dev/null +++ b/src/wrapper/pub_table.jl @@ -0,0 +1,35 @@ +# Julia wrapper for header: /usr/include/scip/pub_table.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPtableGetData(table) + ccall((:SCIPtableGetData, libscip), Ptr{SCIP_TABLEDATA}, (Ptr{SCIP_TABLE},), table) +end + +function SCIPtableSetData(table, tabledata) + ccall((:SCIPtableSetData, libscip), Cvoid, (Ptr{SCIP_TABLE}, Ptr{SCIP_TABLEDATA}), table, tabledata) +end + +function SCIPtableGetName(table) + ccall((:SCIPtableGetName, libscip), Cstring, (Ptr{SCIP_TABLE},), table) +end + +function SCIPtableGetDesc(table) + ccall((:SCIPtableGetDesc, libscip), Cstring, (Ptr{SCIP_TABLE},), table) +end + +function SCIPtableGetPosition(table) + ccall((:SCIPtableGetPosition, libscip), Cint, (Ptr{SCIP_TABLE},), table) +end + +function SCIPtableGetEarliestStage(table) + ccall((:SCIPtableGetEarliestStage, libscip), SCIP_STAGE, (Ptr{SCIP_TABLE},), table) +end + +function SCIPtableIsActive(table) + ccall((:SCIPtableIsActive, libscip), UInt32, (Ptr{SCIP_TABLE},), table) +end + +function SCIPtableIsInitialized(table) + ccall((:SCIPtableIsInitialized, libscip), UInt32, (Ptr{SCIP_TABLE},), table) +end diff --git a/src/wrapper/pub_tree.jl b/src/wrapper/pub_tree.jl new file mode 100644 index 00000000..e500336c --- /dev/null +++ b/src/wrapper/pub_tree.jl @@ -0,0 +1,103 @@ +# Julia wrapper for header: /usr/include/scip/pub_tree.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPnodeCompLowerbound(elem1, elem2) + ccall((:SCIPnodeCompLowerbound, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPnodeGetParentBranchings(node, branchvars, branchbounds, boundtypes, nbranchvars, branchvarssize) + ccall((:SCIPnodeGetParentBranchings, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, branchvars, branchbounds, boundtypes, nbranchvars, branchvarssize) +end + +function SCIPnodeGetAncestorBranchings(node, branchvars, branchbounds, boundtypes, nbranchvars, branchvarssize) + ccall((:SCIPnodeGetAncestorBranchings, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, branchvars, branchbounds, boundtypes, nbranchvars, branchvarssize) +end + +function SCIPnodeGetAncestorBranchingsPart(node, parent, branchvars, branchbounds, boundtypes, nbranchvars, branchvarssize) + ccall((:SCIPnodeGetAncestorBranchingsPart, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, parent, branchvars, branchbounds, boundtypes, nbranchvars, branchvarssize) +end + +function SCIPnodePrintAncestorBranchings(node, file) + ccall((:SCIPnodePrintAncestorBranchings, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{FILE}), node, file) +end + +function SCIPnodeGetAncestorBranchingPath(node, branchvars, branchbounds, boundtypes, nbranchvars, branchvarssize, nodeswitches, nnodes, nodeswitchsize) + ccall((:SCIPnodeGetAncestorBranchingPath, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}, Cint), node, branchvars, branchbounds, boundtypes, nbranchvars, branchvarssize, nodeswitches, nnodes, nodeswitchsize) +end + +function SCIPnodesSharePath(node1, node2) + ccall((:SCIPnodesSharePath, libscip), UInt32, (Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), node1, node2) +end + +function SCIPnodesGetCommonAncestor(node1, node2) + ccall((:SCIPnodesGetCommonAncestor, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), node1, node2) +end + +function SCIPnodeGetType(node) + ccall((:SCIPnodeGetType, libscip), SCIP_NODETYPE, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetNumber(node) + ccall((:SCIPnodeGetNumber, libscip), Clonglong, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetDepth(node) + ccall((:SCIPnodeGetDepth, libscip), Cint, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetLowerbound(node) + ccall((:SCIPnodeGetLowerbound, libscip), Cdouble, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetEstimate(node) + ccall((:SCIPnodeGetEstimate, libscip), Cdouble, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetReopttype(node) + ccall((:SCIPnodeGetReopttype, libscip), SCIP_REOPTTYPE, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetReoptID(node) + ccall((:SCIPnodeGetReoptID, libscip), UInt32, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeSetReopttype(node, reopttype) + ccall((:SCIPnodeSetReopttype, libscip), Cvoid, (Ptr{SCIP_NODE}, SCIP_REOPTTYPE), node, reopttype) +end + +function SCIPnodeSetReoptID(node, id) + ccall((:SCIPnodeSetReoptID, libscip), Cvoid, (Ptr{SCIP_NODE}, UInt32), node, id) +end + +function SCIPnodeGetNDomchg(node, nbranchings, nconsprop, nprop) + ccall((:SCIPnodeGetNDomchg, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), node, nbranchings, nconsprop, nprop) +end + +function SCIPnodeGetDomchg(node) + ccall((:SCIPnodeGetDomchg, libscip), Ptr{SCIP_DOMCHG}, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetParent(node) + ccall((:SCIPnodeGetParent, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetAddedConss(node, addedconss, naddedconss, addedconsssize) + ccall((:SCIPnodeGetAddedConss, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), node, addedconss, naddedconss, addedconsssize) +end + +function SCIPnodeGetNAddedConss(node) + ccall((:SCIPnodeGetNAddedConss, libscip), Cint, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeIsActive(node) + ccall((:SCIPnodeIsActive, libscip), UInt32, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeIsPropagatedAgain(node) + ccall((:SCIPnodeIsPropagatedAgain, libscip), UInt32, (Ptr{SCIP_NODE},), node) +end + +function SCIPnodeGetConssetchg(node) + ccall((:SCIPnodeGetConssetchg, libscip), Ptr{SCIP_CONSSETCHG}, (Ptr{SCIP_NODE},), node) +end diff --git a/src/wrapper/pub_var.jl b/src/wrapper/pub_var.jl new file mode 100644 index 00000000..1255ad3b --- /dev/null +++ b/src/wrapper/pub_var.jl @@ -0,0 +1,667 @@ +# Julia wrapper for header: /usr/include/scip/pub_var.h +# Automatically generated using Clang.jl wrap_c + + +function SCIPvarGetNLocksDown(var) + ccall((:SCIPvarGetNLocksDown, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNLocksUp(var) + ccall((:SCIPvarGetNLocksUp, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNLocksUpType(var, locktype) + ccall((:SCIPvarGetNLocksUpType, libscip), Cint, (Ptr{SCIP_VAR}, SCIP_LOCKTYPE), var, locktype) +end + +function SCIPvarGetNLocksDownType(var, locktype) + ccall((:SCIPvarGetNLocksDownType, libscip), Cint, (Ptr{SCIP_VAR}, SCIP_LOCKTYPE), var, locktype) +end + +function SCIPvarMayRoundDown(var) + ccall((:SCIPvarMayRoundDown, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarMayRoundUp(var) + ccall((:SCIPvarMayRoundUp, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarCompareActiveAndNegated(var1, var2) + ccall((:SCIPvarCompareActiveAndNegated, libscip), Cint, (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), var1, var2) +end + +function SCIPvarCompActiveAndNegated(elem1, elem2) + ccall((:SCIPvarCompActiveAndNegated, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPvarCompare(var1, var2) + ccall((:SCIPvarCompare, libscip), Cint, (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), var1, var2) +end + +function SCIPvarComp(elem1, elem2) + ccall((:SCIPvarComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPvarCompObj(elem1, elem2) + ccall((:SCIPvarCompObj, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPvarGetHashkey(userptr, elem) + ccall((:SCIPvarGetHashkey, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Ptr{Cvoid}), userptr, elem) +end + +function SCIPvarIsHashkeyEq(userptr, key1, key2) + ccall((:SCIPvarIsHashkeyEq, libscip), UInt32, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), userptr, key1, key2) +end + +function SCIPvarGetHashkeyVal(userptr, key) + ccall((:SCIPvarGetHashkeyVal, libscip), UInt64, (Ptr{Cvoid}, Ptr{Cvoid}), userptr, key) +end + +function SCIPvarsGetProbvar(vars, nvars) + ccall((:SCIPvarsGetProbvar, libscip), Cvoid, (Ptr{Ptr{SCIP_VAR}}, Cint), vars, nvars) +end + +function SCIPvarGetProbvar(var) + ccall((:SCIPvarGetProbvar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarsGetProbvarBinary(vars, negatedarr, nvars) + ccall((:SCIPvarsGetProbvarBinary, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{UInt32}}, Cint), vars, negatedarr, nvars) +end + +function SCIPvarGetProbvarBinary(var, negated) + ccall((:SCIPvarGetProbvarBinary, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{UInt32}), var, negated) +end + +function SCIPvarGetProbvarBound(var, bound, boundtype) + ccall((:SCIPvarGetProbvarBound, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}), var, bound, boundtype) +end + +function SCIPvarGetProbvarHole(var, left, right) + ccall((:SCIPvarGetProbvarHole, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), var, left, right) +end + +function SCIPvarGetOrigvarSum(var, scalar, constant) + ccall((:SCIPvarGetOrigvarSum, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), var, scalar, constant) +end + +function SCIPvarIsTransformedOrigvar(var) + ccall((:SCIPvarIsTransformedOrigvar, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNBranchings(var, dir) + ccall((:SCIPvarGetNBranchings, libscip), Clonglong, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) +end + +function SCIPvarGetNBranchingsCurrentRun(var, dir) + ccall((:SCIPvarGetNBranchingsCurrentRun, libscip), Clonglong, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) +end + +function SCIPvarGetInferenceSum(var, dir) + ccall((:SCIPvarGetInferenceSum, libscip), Cdouble, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) +end + +function SCIPvarGetInferenceSumCurrentRun(var, dir) + ccall((:SCIPvarGetInferenceSumCurrentRun, libscip), Cdouble, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) +end + +function SCIPvarGetCutoffSum(var, dir) + ccall((:SCIPvarGetCutoffSum, libscip), Cdouble, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) +end + +function SCIPvarGetCutoffSumCurrentRun(var, dir) + ccall((:SCIPvarGetCutoffSumCurrentRun, libscip), Cdouble, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) +end + +function SCIPvarGetAvgBranchdepth(var, dir) + ccall((:SCIPvarGetAvgBranchdepth, libscip), Cdouble, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) +end + +function SCIPvarGetAvgBranchdepthCurrentRun(var, dir) + ccall((:SCIPvarGetAvgBranchdepthCurrentRun, libscip), Cdouble, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) +end + +function SCIPvarHasImplic(var, varfixing, implvar, impltype) + ccall((:SCIPvarHasImplic, libscip), UInt32, (Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE), var, varfixing, implvar, impltype) +end + +function SCIPvarHasBinaryImplic(var, varfixing, implvar, implvarfixing) + ccall((:SCIPvarHasBinaryImplic, libscip), UInt32, (Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, UInt32), var, varfixing, implvar, implvarfixing) +end + +function SCIPvarsHaveCommonClique(var1, value1, var2, value2, regardimplics) + ccall((:SCIPvarsHaveCommonClique, libscip), UInt32, (Ptr{SCIP_VAR}, UInt32, Ptr{SCIP_VAR}, UInt32, UInt32), var1, value1, var2, value2, regardimplics) +end + +function SCIPvarGetAggregatedObj(var, aggrobj) + ccall((:SCIPvarGetAggregatedObj, libscip), SCIP_RETCODE, (Ptr{SCIP_VAR}, Ptr{Cdouble}), var, aggrobj) +end + +function SCIPvarSetInitial(var, initial) + ccall((:SCIPvarSetInitial, libscip), SCIP_RETCODE, (Ptr{SCIP_VAR}, UInt32), var, initial) +end + +function SCIPvarSetRemovable(var, removable) + ccall((:SCIPvarSetRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP_VAR}, UInt32), var, removable) +end + +function SCIPvarGetName(var) + ccall((:SCIPvarGetName, libscip), Cstring, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNUses(var) + ccall((:SCIPvarGetNUses, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetData(var) + ccall((:SCIPvarGetData, libscip), Ptr{SCIP_VARDATA}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarSetData(var, vardata) + ccall((:SCIPvarSetData, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{SCIP_VARDATA}), var, vardata) +end + +function SCIPvarSetDelorigData(var, vardelorig) + ccall((:SCIPvarSetDelorigData, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{Cvoid}), var, vardelorig) +end + +function SCIPvarSetTransData(var, vartrans) + ccall((:SCIPvarSetTransData, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{Cvoid}), var, vartrans) +end + +function SCIPvarSetDeltransData(var, vardeltrans) + ccall((:SCIPvarSetDeltransData, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{Cvoid}), var, vardeltrans) +end + +function SCIPvarSetCopyData(var, varcopy) + ccall((:SCIPvarSetCopyData, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{Cvoid}), var, varcopy) +end + +function SCIPvarGetStatus(var) + ccall((:SCIPvarGetStatus, libscip), SCIP_VARSTATUS, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsOriginal(var) + ccall((:SCIPvarIsOriginal, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsTransformed(var) + ccall((:SCIPvarIsTransformed, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsNegated(var) + ccall((:SCIPvarIsNegated, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetType(var) + ccall((:SCIPvarGetType, libscip), SCIP_VARTYPE, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsBinary(var) + ccall((:SCIPvarIsBinary, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsIntegral(var) + ccall((:SCIPvarIsIntegral, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsInitial(var) + ccall((:SCIPvarIsInitial, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsRemovable(var) + ccall((:SCIPvarIsRemovable, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsDeleted(var) + ccall((:SCIPvarIsDeleted, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarMarkDeletable(var) + ccall((:SCIPvarMarkDeletable, libscip), Cvoid, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarMarkNotDeletable(var) + ccall((:SCIPvarMarkNotDeletable, libscip), Cvoid, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsDeletable(var) + ccall((:SCIPvarIsDeletable, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarMarkDeleteGlobalStructures(var) + ccall((:SCIPvarMarkDeleteGlobalStructures, libscip), Cvoid, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsActive(var) + ccall((:SCIPvarIsActive, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetIndex(var) + ccall((:SCIPvarGetIndex, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetProbindex(var) + ccall((:SCIPvarGetProbindex, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetTransVar(var) + ccall((:SCIPvarGetTransVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetCol(var) + ccall((:SCIPvarGetCol, libscip), Ptr{SCIP_COL}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsInLP(var) + ccall((:SCIPvarIsInLP, libscip), UInt32, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetAggrVar(var) + ccall((:SCIPvarGetAggrVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetAggrScalar(var) + ccall((:SCIPvarGetAggrScalar, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetAggrConstant(var) + ccall((:SCIPvarGetAggrConstant, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetMultaggrNVars(var) + ccall((:SCIPvarGetMultaggrNVars, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetMultaggrVars(var) + ccall((:SCIPvarGetMultaggrVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetMultaggrScalars(var) + ccall((:SCIPvarGetMultaggrScalars, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetMultaggrConstant(var) + ccall((:SCIPvarGetMultaggrConstant, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNegatedVar(var) + ccall((:SCIPvarGetNegatedVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNegationVar(var) + ccall((:SCIPvarGetNegationVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNegationConstant(var) + ccall((:SCIPvarGetNegationConstant, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetObj(var) + ccall((:SCIPvarGetObj, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetUnchangedObj(var) + ccall((:SCIPvarGetUnchangedObj, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetLbOriginal(var) + ccall((:SCIPvarGetLbOriginal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetUbOriginal(var) + ccall((:SCIPvarGetUbOriginal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetHolelistOriginal(var) + ccall((:SCIPvarGetHolelistOriginal, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetLbGlobal(var) + ccall((:SCIPvarGetLbGlobal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetUbGlobal(var) + ccall((:SCIPvarGetUbGlobal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetHolelistGlobal(var) + ccall((:SCIPvarGetHolelistGlobal, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBestBoundGlobal(var) + ccall((:SCIPvarGetBestBoundGlobal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetWorstBoundGlobal(var) + ccall((:SCIPvarGetWorstBoundGlobal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetLbLocal(var) + ccall((:SCIPvarGetLbLocal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetUbLocal(var) + ccall((:SCIPvarGetUbLocal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetHolelistLocal(var) + ccall((:SCIPvarGetHolelistLocal, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBestBoundLocal(var) + ccall((:SCIPvarGetBestBoundLocal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetWorstBoundLocal(var) + ccall((:SCIPvarGetWorstBoundLocal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBestBoundType(var) + ccall((:SCIPvarGetBestBoundType, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetWorstBoundType(var) + ccall((:SCIPvarGetWorstBoundType, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetLbLazy(var) + ccall((:SCIPvarGetLbLazy, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetUbLazy(var) + ccall((:SCIPvarGetUbLazy, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBranchFactor(var) + ccall((:SCIPvarGetBranchFactor, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBranchPriority(var) + ccall((:SCIPvarGetBranchPriority, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBranchDirection(var) + ccall((:SCIPvarGetBranchDirection, libscip), SCIP_BRANCHDIR, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNVlbs(var) + ccall((:SCIPvarGetNVlbs, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetVlbVars(var) + ccall((:SCIPvarGetVlbVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetVlbCoefs(var) + ccall((:SCIPvarGetVlbCoefs, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetVlbConstants(var) + ccall((:SCIPvarGetVlbConstants, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNVubs(var) + ccall((:SCIPvarGetNVubs, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetVubVars(var) + ccall((:SCIPvarGetVubVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetVubCoefs(var) + ccall((:SCIPvarGetVubCoefs, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetVubConstants(var) + ccall((:SCIPvarGetVubConstants, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNImpls(var, varfixing) + ccall((:SCIPvarGetNImpls, libscip), Cint, (Ptr{SCIP_VAR}, UInt32), var, varfixing) +end + +function SCIPvarGetImplVars(var, varfixing) + ccall((:SCIPvarGetImplVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR}, UInt32), var, varfixing) +end + +function SCIPvarGetImplTypes(var, varfixing) + ccall((:SCIPvarGetImplTypes, libscip), Ptr{SCIP_BOUNDTYPE}, (Ptr{SCIP_VAR}, UInt32), var, varfixing) +end + +function SCIPvarGetImplBounds(var, varfixing) + ccall((:SCIPvarGetImplBounds, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR}, UInt32), var, varfixing) +end + +function SCIPvarGetImplIds(var, varfixing) + ccall((:SCIPvarGetImplIds, libscip), Ptr{Cint}, (Ptr{SCIP_VAR}, UInt32), var, varfixing) +end + +function SCIPvarGetNCliques(var, varfixing) + ccall((:SCIPvarGetNCliques, libscip), Cint, (Ptr{SCIP_VAR}, UInt32), var, varfixing) +end + +function SCIPvarGetCliques(var, varfixing) + ccall((:SCIPvarGetCliques, libscip), Ptr{Ptr{SCIP_CLIQUE}}, (Ptr{SCIP_VAR}, UInt32), var, varfixing) +end + +function SCIPvarGetLPSol(var) + ccall((:SCIPvarGetLPSol, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNLPSol(var) + ccall((:SCIPvarGetNLPSol, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBdchgInfoLb(var, pos) + ccall((:SCIPvarGetBdchgInfoLb, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Cint), var, pos) +end + +function SCIPvarGetNBdchgInfosLb(var) + ccall((:SCIPvarGetNBdchgInfosLb, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBdchgInfoUb(var, pos) + ccall((:SCIPvarGetBdchgInfoUb, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Cint), var, pos) +end + +function SCIPvarGetNBdchgInfosUb(var) + ccall((:SCIPvarGetNBdchgInfosUb, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetValuehistory(var) + ccall((:SCIPvarGetValuehistory, libscip), Ptr{SCIP_VALUEHISTORY}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetLPSol_rec(var) + ccall((:SCIPvarGetLPSol_rec, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetNLPSol_rec(var) + ccall((:SCIPvarGetNLPSol_rec, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetPseudoSol(var) + ccall((:SCIPvarGetPseudoSol, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetSol(var, getlpval) + ccall((:SCIPvarGetSol, libscip), Cdouble, (Ptr{SCIP_VAR}, UInt32), var, getlpval) +end + +function SCIPvarGetRootSol(var) + ccall((:SCIPvarGetRootSol, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBestRootSol(var) + ccall((:SCIPvarGetBestRootSol, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBestRootRedcost(var) + ccall((:SCIPvarGetBestRootRedcost, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBestRootLPObjval(var) + ccall((:SCIPvarGetBestRootLPObjval, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarSetBestRootSol(var, rootsol, rootredcost, rootlpobjval) + ccall((:SCIPvarSetBestRootSol, libscip), Cvoid, (Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), var, rootsol, rootredcost, rootlpobjval) +end + +function SCIPvarGetAvgSol(var) + ccall((:SCIPvarGetAvgSol, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetLbchgInfo(var, bdchgidx, after) + ccall((:SCIPvarGetLbchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), var, bdchgidx, after) +end + +function SCIPvarGetUbchgInfo(var, bdchgidx, after) + ccall((:SCIPvarGetUbchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), var, bdchgidx, after) +end + +function SCIPvarGetBdchgInfo(var, boundtype, bdchgidx, after) + ccall((:SCIPvarGetBdchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, UInt32), var, boundtype, bdchgidx, after) +end + +function SCIPvarGetLbAtIndex(var, bdchgidx, after) + ccall((:SCIPvarGetLbAtIndex, libscip), Cdouble, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), var, bdchgidx, after) +end + +function SCIPvarGetUbAtIndex(var, bdchgidx, after) + ccall((:SCIPvarGetUbAtIndex, libscip), Cdouble, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), var, bdchgidx, after) +end + +function SCIPvarGetBdAtIndex(var, boundtype, bdchgidx, after) + ccall((:SCIPvarGetBdAtIndex, libscip), Cdouble, (Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, UInt32), var, boundtype, bdchgidx, after) +end + +function SCIPvarWasFixedAtIndex(var, bdchgidx, after) + ccall((:SCIPvarWasFixedAtIndex, libscip), UInt32, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, UInt32), var, bdchgidx, after) +end + +function SCIPvarGetLastBdchgIndex(var) + ccall((:SCIPvarGetLastBdchgIndex, libscip), Ptr{SCIP_BDCHGIDX}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetLastBdchgDepth(var) + ccall((:SCIPvarGetLastBdchgDepth, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarWasFixedEarlier(var1, var2) + ccall((:SCIPvarWasFixedEarlier, libscip), UInt32, (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), var1, var2) +end + +function SCIPbdchgidxIsEarlier(bdchgidx1, bdchgidx2) + ccall((:SCIPbdchgidxIsEarlier, libscip), UInt32, (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), bdchgidx1, bdchgidx2) +end + +function SCIPbdchgidxIsEarlierNonNull(bdchgidx1, bdchgidx2) + ccall((:SCIPbdchgidxIsEarlierNonNull, libscip), UInt32, (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), bdchgidx1, bdchgidx2) +end + +function SCIPbdchginfoGetOldbound(bdchginfo) + ccall((:SCIPbdchginfoGetOldbound, libscip), Cdouble, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetNewbound(bdchginfo) + ccall((:SCIPbdchginfoGetNewbound, libscip), Cdouble, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetVar(bdchginfo) + ccall((:SCIPbdchginfoGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetChgtype(bdchginfo) + ccall((:SCIPbdchginfoGetChgtype, libscip), SCIP_BOUNDCHGTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetBoundtype(bdchginfo) + ccall((:SCIPbdchginfoGetBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetDepth(bdchginfo) + ccall((:SCIPbdchginfoGetDepth, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetPos(bdchginfo) + ccall((:SCIPbdchginfoGetPos, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetIdx(bdchginfo) + ccall((:SCIPbdchginfoGetIdx, libscip), Ptr{SCIP_BDCHGIDX}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetInferVar(bdchginfo) + ccall((:SCIPbdchginfoGetInferVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetInferCons(bdchginfo) + ccall((:SCIPbdchginfoGetInferCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetInferProp(bdchginfo) + ccall((:SCIPbdchginfoGetInferProp, libscip), Ptr{SCIP_PROP}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetInferInfo(bdchginfo) + ccall((:SCIPbdchginfoGetInferInfo, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoGetInferBoundtype(bdchginfo) + ccall((:SCIPbdchginfoGetInferBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoIsRedundant(bdchginfo) + ccall((:SCIPbdchginfoIsRedundant, libscip), UInt32, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoHasInferenceReason(bdchginfo) + ccall((:SCIPbdchginfoHasInferenceReason, libscip), UInt32, (Ptr{SCIP_BDCHGINFO},), bdchginfo) +end + +function SCIPbdchginfoIsTighter(bdchginfo1, bdchginfo2) + ccall((:SCIPbdchginfoIsTighter, libscip), UInt32, (Ptr{SCIP_BDCHGINFO}, Ptr{SCIP_BDCHGINFO}), bdchginfo1, bdchginfo2) +end + +function SCIPboundchgGetNewbound(boundchg) + ccall((:SCIPboundchgGetNewbound, libscip), Cdouble, (Ptr{SCIP_BOUNDCHG},), boundchg) +end + +function SCIPboundchgGetVar(boundchg) + ccall((:SCIPboundchgGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BOUNDCHG},), boundchg) +end + +function SCIPboundchgGetBoundchgtype(boundchg) + ccall((:SCIPboundchgGetBoundchgtype, libscip), SCIP_BOUNDCHGTYPE, (Ptr{SCIP_BOUNDCHG},), boundchg) +end + +function SCIPboundchgGetBoundtype(boundchg) + ccall((:SCIPboundchgGetBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BOUNDCHG},), boundchg) +end + +function SCIPboundchgIsRedundant(boundchg) + ccall((:SCIPboundchgIsRedundant, libscip), UInt32, (Ptr{SCIP_BOUNDCHG},), boundchg) +end + +function SCIPdomchgGetNBoundchgs(domchg) + ccall((:SCIPdomchgGetNBoundchgs, libscip), Cint, (Ptr{SCIP_DOMCHG},), domchg) +end + +function SCIPdomchgGetBoundchg(domchg, pos) + ccall((:SCIPdomchgGetBoundchg, libscip), Ptr{SCIP_BOUNDCHG}, (Ptr{SCIP_DOMCHG}, Cint), domchg, pos) +end + +function SCIPholelistGetLeft(holelist) + ccall((:SCIPholelistGetLeft, libscip), Cdouble, (Ptr{SCIP_HOLELIST},), holelist) +end + +function SCIPholelistGetRight(holelist) + ccall((:SCIPholelistGetRight, libscip), Cdouble, (Ptr{SCIP_HOLELIST},), holelist) +end + +function SCIPholelistGetNext(holelist) + ccall((:SCIPholelistGetNext, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_HOLELIST},), holelist) +end From 041024d9a8d6260e536905ff958a8d556e5e3b89 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 13:40:36 +0100 Subject: [PATCH 44/82] implement enough of MOI to get to the actual solution query --- src/MOI_wrapper.jl | 99 ++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 91 insertions(+), 8 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 1d7f5468..222d78b7 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -5,17 +5,19 @@ const MOIU = MOI.Utilities const VI = MOI.VariableIndex const CI = MOI.ConstraintIndex +const VarMap = Dict{Ptr{SCIP_VAR}, Int} const ConsMap = Dict{Tuple{DataType, DataType}, Vector{Int}} mutable struct Optimizer <: MOI.AbstractOptimizer mscip::ManagedSCIP + var::VarMap cons::ConsMap - Optimizer() = new(ManagedSCIP(), ConsMap()) + Optimizer() = new(ManagedSCIP(), VarMap(), ConsMap()) end -## convenience methods (not part of MOI) +## convenience functions (not part of MOI) "Returns pointer to SCIP instance" get_scip(o::Optimizer) = get_scip(o.mscip) @@ -23,8 +25,11 @@ get_scip(o::Optimizer) = get_scip(o.mscip) "Returns pointer to SCIP variable" get_var(o::Optimizer, v::VI) = get_var(o.mscip, v.value) +"Returns index of SCIP variable" +get_index(o::Optimizer, var::Ptr{SCIP_VAR}) = o.var[var] + "Returns pointer to SCIP constraint" -get_cons(o::Optimizer, v::CI{F,S}) where {F,S} = get_cons(o.mscip, c.value) +get_cons(o::Optimizer, c::CI{F,S}) where {F,S} = get_cons(o.mscip, c.value) "Extract bounds from sets" bounds(set::MOI.EqualTo{Float64}) = (set.value, set.value) @@ -32,6 +37,28 @@ bounds(set::MOI.GreaterThan{Float64}) = (set.lower, nothing) bounds(set::MOI.LessThan{Float64}) = (nothing, set.upper) bounds(set::MOI.Interval{Float64}) = (set.lower, set.upper) +"Make set from bounds" +function from_bounds(::Type{MOI.EqualTo{Float64}}, lower, upper) + @assert lower == upper + return MOI.EqualTo{Float64}(lower) +end +function from_bounds(::Type{MOI.GreaterThan{Float64}}, lower, upper) + MOI.GreaterThan{Float64}(lower) +end +function from_bounds(::Type{MOI.LessThan{Float64}}, lower, upper) + MOI.LessThan{Float64}(upper) +end +function from_bounds(::Type{MOI.Interval{Float64}}, lower, upper) + MOI.Interval{Float64}(lower, upper) +end + +"Register variable in mapping" +function register!(o::Optimizer, var::Ptr{SCIP_VAR}, index::Int) + @assert !haskey(o.var, var) + o.var[var] = index + return index +end + "Register constraint in mapping" function register!(o::Optimizer, c::CI{F,S}) where {F,S} if haskey(o.cons, (F, S)) @@ -58,8 +85,7 @@ MOI.supports_constraint(o::Optimizer, ::Type{<:SF}, ::Type{<:SS}) = true MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}) = true -MOIU.supports_allocate_load(o::Optimizer, copy_names::Bool) = !copy_names - +MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = !copy_names ## model creation, query and modification @@ -72,6 +98,9 @@ function MOI.empty!(o::Optimizer) finalize(o.mscip) # create a new one o.mscip = ManagedSCIP() + # clear auxiliary mapping structures + o.var = VarMap() + o.cons = ConsMap() return nothing end @@ -79,9 +108,16 @@ function MOI.copy_to(dest::Optimizer, src::MOI.ModelLike; kws...) MOIU.automatic_copy_to(dest, src; kws...) end -MOI.add_variable(o::Optimizer) = MOI.VariableIndex(add_variable(o.mscip)) +function MOI.add_variable(o::Optimizer) + i::Int = add_variable(o.mscip) + var::Ptr{SCIP_VAR} = o.mscip.vars[i][] # i == end + register!(o, var, i) + return MOI.VariableIndex(i) +end + MOI.add_variables(o::Optimizer, n) = [MOI.add_variable(o) for i=1:n] MOI.get(o::Optimizer, ::MOI.NumberOfVariables) = length(o.mscip.vars) +MOI.get(o::Optimizer, ::MOI.ListOfVariableIndices) = VI.(1:length(o.mscip.vars)) function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, set::S) where S <: SS @@ -113,6 +149,38 @@ function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} haskey(o.cons, (F, S)) ? length(o.cons[F, S]) : 0 end +function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, + ci::CI{MOI.SingleVariable, S}) where S <: SS + MOI.SingleVariable(ci) +end + +function MOI.get(o::Optimizer, ::MOI.ConstraintSet, + ci::CI{MOI.SingleVariable, S}) where S <: SS + var = get_var(o.mscip, ci.value) + lb, ub = SCIPvarGetLbOriginal(var), SCIPvarGetUbOriginal(var) + from_bounds(S, lb, ub) +end + +function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, + ci::CI{MOI.ScalarAffineFunction{Float64}, S}) where S <: SS + scip, cons = get_scip(o), get_cons(o, ci) + nvars::Int = SCIPgetNVarsLinear(scip, cons) + vars = unsafe_wrap(Array{Ptr{SCIP_VAR}}, SCIPgetVarsLinear(scip, cons), nvars) + vals = unsafe_wrap(Array{Float64}, SCIPgetValsLinear(scip, cons), nvars) + + terms = [MOI.ScalarAffineTerm{Float64}(vals[i], VI(get_index(o, vars[i]))) + for i=1:nvars] + # can not identify constant anymore (is merged with lhs,rhs) + return MOI.ScalarAffineFunction{Float64}(terms, 0.0) +end + +function MOI.get(o::Optimizer, ::MOI.ConstraintSet, + ci::CI{MOI.ScalarAffineFunction{Float64}, S}) where S <: SS + scip, cons = get_scip(o), get_cons(o, ci) + lhs, rhs = SCIPgetLhsLinear(scip, cons), SCIPgetRhsLinear(scip, cons) + from_bounds(S, lhs, rhs) +end + function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, obj::MOI.ScalarAffineFunction{Float64}) @@ -123,9 +191,12 @@ function MOI.set(o::Optimizer, @SC SCIPchgVarObj(scip, v[], 0.0) end - # set new objective coefficients + # set new objective coefficients, summing coefficients for t in obj.terms - @SC SCIPchgVarObj(scip, get_var(o, t.variable_index), t.coefficient) + var = get_var(o, t.variable_index) + oldcoef = SCIPvarGetObj(var) + newcoef = oldcoef + t.coefficient + @SC SCIPchgVarObj(scip, var, newcoef) end @SC SCIPaddOrigObjoffset(scip, obj.constant - SCIPgetOrigObjoffset(scip)) @@ -133,6 +204,18 @@ function MOI.set(o::Optimizer, return nothing end +function MOI.get(o::Optimizer, + ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}) + terms = MOI.ScalarAffineTerm{Float64}[] + for i = 1:length(o.mscip.vars) + vi = VI(i) + coef = SCIPvarGetObj(get_var(o, vi)) + coef == 0.0 || push!(terms, MOI.ScalarAffineTerm{Float64}(coef, vi)) + end + constant = SCIPgetOrigObjoffset(get_scip(o)) + return MOI.ScalarAffineFunction{Float64}(terms, constant) +end + function MOI.set(o::Optimizer, ::MOI.ObjectiveSense, sense::MOI.OptimizationSense) if sense == MOI.MIN_SENSE From e74b98db006e2bfb42f7ef19a7907268a6f7ac5c Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 18:11:12 +0100 Subject: [PATCH 45/82] implement status and solution queries --- src/MOI_wrapper.jl | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 222d78b7..0eed49ca 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -69,6 +69,7 @@ function register!(o::Optimizer, c::CI{F,S}) where {F,S} return c end + ## general queries and support MOI.get(::Optimizer, ::MOI.SolverName) = "SCIP" @@ -87,6 +88,7 @@ MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = !copy_names + ## model creation, query and modification function MOI.is_empty(o::Optimizer) @@ -239,3 +241,45 @@ function MOI.optimize!(o::Optimizer) @SC SCIPsolve(o.mscip.scip[]) return nothing end + +term_status_map = Dict( + SCIP_STATUS_UNKNOWN => MOI.OPTIMIZE_NOT_CALLED, + SCIP_STATUS_USERINTERRUPT => MOI.INTERRUPTED, + SCIP_STATUS_NODELIMIT => MOI.NODE_LIMIT, + SCIP_STATUS_TOTALNODELIMIT => MOI.NODE_LIMIT, + SCIP_STATUS_STALLNODELIMIT => MOI.OTHER_LIMIT, + SCIP_STATUS_TIMELIMIT => MOI.TIME_LIMIT, + SCIP_STATUS_MEMLIMIT => MOI.MEMORY_LIMIT, + SCIP_STATUS_GAPLIMIT => MOI.OTHER_LIMIT, + SCIP_STATUS_SOLLIMIT => MOI.SOLUTION_LIMIT, + SCIP_STATUS_BESTSOLLIMIT => MOI.OTHER_LIMIT, + SCIP_STATUS_RESTARTLIMIT => MOI.OTHER_LIMIT, + SCIP_STATUS_OPTIMAL => MOI.OPTIMAL, + SCIP_STATUS_INFEASIBLE => MOI.INFEASIBLE, + SCIP_STATUS_UNBOUNDED => MOI.DUAL_INFEASIBLE, + SCIP_STATUS_INFORUNBD => MOI.INFEASIBLE_OR_UNBOUNDED, + SCIP_STATUS_TERMINATE => MOI.INTERRUPTED, +) + +function MOI.get(o::Optimizer, ::MOI.TerminationStatus) + term_status_map[SCIPgetStatus(get_scip(o))] +end + +function MOI.get(o::Optimizer, ::MOI.PrimalStatus) + SCIPgetNSols(get_scip(o)) > 0 ? MOI.FEASIBLE_POINT : MOI.NO_SOLUTION +end + +function MOI.get(o::Optimizer, ::MOI.ObjectiveValue) + scip = get_scip(o) + return SCIPgetSolOrigObj(scip, SCIPgetBestSol(scip)) +end + +function MOI.get(o::Optimizer, ::MOI.VariablePrimal, vi::VI) + scip = get_scip(o) + return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, vi)) +end + +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}) + scip = get_scip(o) + return SCIPgetActivityLinear(scip, get_cons(o, ci), SCIPgetBestSol(scip)) +end From c6ed1233df1a73455d99d3239de06d5838eebb83 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 18:21:24 +0100 Subject: [PATCH 46/82] add allow_modification(o) to reset SCIP stage --- src/MOI_wrapper.jl | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 0eed49ca..499239b7 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -69,6 +69,14 @@ function register!(o::Optimizer, c::CI{F,S}) where {F,S} return c end +"Go back from solved stage to problem modification stage, invalidating results." +function allow_modification(o::Optimizer) + scip = get_scip(o) + if SCIPgetStage(scip) != SCIP_STAGE_PROBLEM + @SC SCIPfreeTransform(scip) + end + return nothing +end ## general queries and support @@ -111,6 +119,7 @@ function MOI.copy_to(dest::Optimizer, src::MOI.ModelLike; kws...) end function MOI.add_variable(o::Optimizer) + allow_modification(o) i::Int = add_variable(o.mscip) var::Ptr{SCIP_VAR} = o.mscip.vars[i][] # i == end register!(o, var, i) @@ -123,6 +132,7 @@ MOI.get(o::Optimizer, ::MOI.ListOfVariableIndices) = VI.(1:length(o.mscip.vars)) function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, set::S) where S <: SS + allow_modification(o) var = get_var(o, func.variable) lb, ub = bounds(set) lb == nothing || @SC SCIPchgVarLb(get_scip(o), var, lb) @@ -134,6 +144,7 @@ end function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64}, set::S) where {S <: SS} + allow_modification(o) scip = get_scip(o) varidx = [t.variable_index.value for t in func.terms] @@ -186,6 +197,7 @@ end function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, obj::MOI.ScalarAffineFunction{Float64}) + allow_modification(o) scip = get_scip(o) # reset objective coefficient of all variables first @@ -220,6 +232,7 @@ end function MOI.set(o::Optimizer, ::MOI.ObjectiveSense, sense::MOI.OptimizationSense) + allow_modification(o) if sense == MOI.MIN_SENSE @SC SCIPsetObjsense(get_scip(o), SCIP_OBJSENSE_MINIMIZE) elseif sense == MOI.MAX_SENSE From 60c26eccafe4eb762d96b3999ac6a1893b00d5bc Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 18:50:05 +0100 Subject: [PATCH 47/82] implement more problem modification --- src/MOI_wrapper.jl | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 499239b7..975f63b7 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -142,6 +142,16 @@ function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, return register!(o, CI{MOI.SingleVariable, S}(i)) end +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, + ci::CI{MOI.SingleVariable,S}, set::S) where {S <: SS} + allow_modification(o) + var = get_var(o, VI(ci.value)) # cons index is actually var index + lb, ub = bounds(set) + lb == nothing || @SC SCIPchgVarLb(get_scip(o), var, lb) + ub == nothing || @SC SCIPchgVarUb(get_scip(o), var, ub) + return nothing +end + function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64}, set::S) where {S <: SS} allow_modification(o) @@ -247,6 +257,22 @@ function MOI.get(o::Optimizer, ::MOI.ObjectiveSense) MOI.MIN_SENSE end +function MOI.modify(o::Optimizer, ci::CI{MOI.ScalarAffineFunction{Float64}, <:SS}, + change::MOI.ScalarCoefficientChange{Float64}) + allow_modification(o) + @SC SCIPchgCoefLinear(get_scip(o), get_cons(o, ci), + get_var(o, change.variable), change.new_coefficient) + return nothing +end + +function MOI.modify(o::Optimizer, + ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, + change::MOI.ScalarCoefficientChange{Float64}) + allow_modification(o) + @SC SCIPchgVarObj(get_scip(o), get_var(o, change.variable), + change.new_coefficient) + return nothing +end ## optimization and results @@ -282,6 +308,8 @@ function MOI.get(o::Optimizer, ::MOI.PrimalStatus) SCIPgetNSols(get_scip(o)) > 0 ? MOI.FEASIBLE_POINT : MOI.NO_SOLUTION end +MOI.get(o::Optimizer, ::MOI.ResultCount) = SCIPgetNSols(get_scip(o)) + function MOI.get(o::Optimizer, ::MOI.ObjectiveValue) scip = get_scip(o) return SCIPgetSolOrigObj(scip, SCIPgetBestSol(scip)) From b97dcffe9fabd814da05f290240b26b0a07fbb70 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 19:34:39 +0100 Subject: [PATCH 48/82] do not support linear constraints with constant offset - because I would need to merge it with lhs/rhs - but then I can not modify the constraint with set(, ConstraintSet, ) - so I just throw AddConstraintNotAllowed --- src/MOI_wrapper.jl | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 975f63b7..404b30e9 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -154,6 +154,11 @@ end function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64}, set::S) where {S <: SS} + if func.constant != 0.0 + msg = "SCIP does not support linear constraints with a constant offset." + throw(MOI.AddConstraintNotAllowed{MOI.ScalarAffineFunction{Float64}, S}(msg)) + end + allow_modification(o) scip = get_scip(o) @@ -161,13 +166,29 @@ function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64 coefs = [t.coefficient for t in func.terms] lhs, rhs = bounds(set) - lhs = lhs == nothing ? -SCIPinfinity(scip) : lhs - func.constant - rhs = rhs == nothing ? SCIPinfinity(scip) : rhs - func.constant + lhs = lhs == nothing ? -SCIPinfinity(scip) : lhs + rhs = rhs == nothing ? SCIPinfinity(scip) : rhs i = add_linear_constraint(o.mscip, varidx, coefs, lhs, rhs) return register!(o, CI{MOI.ScalarAffineFunction{Float64}, S}(i)) end +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, + ci::CI{MOI.ScalarAffineFunction{Float64},S}, set::S) where {S <: SS} + allow_modification(o) + scip = get_scip(o) + cons = get_cons(o, ci) + + lhs, rhs = bounds(set) + lhs = lhs == nothing ? -SCIPinfinity(scip) : lhs + rhs = rhs == nothing ? SCIPinfinity(scip) : rhs + + @SC SCIPchgLhsLinear(scip, cons, lhs) + @SC SCIPchgRhsLinear(scip, cons, rhs) + + return nothing +end + function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} haskey(o.cons, (F, S)) ? length(o.cons[F, S]) : 0 end From 85ea5050434ee3fdbdb23701464cfaff5a928309 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 19:36:03 +0100 Subject: [PATCH 49/82] add more solution queries --- src/MOI_wrapper.jl | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 404b30e9..40f48a61 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -341,6 +341,11 @@ function MOI.get(o::Optimizer, ::MOI.VariablePrimal, vi::VI) return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, vi)) end +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{MOI.SingleVariable,<:SS}) + scip = get_scip(o) + return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, VI(ci.variable))) +end + function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}) scip = get_scip(o) return SCIPgetActivityLinear(scip, get_cons(o, ci), SCIPgetBestSol(scip)) From 0abb8162733571a1340a767b20dae6306bbff52b Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 19:36:22 +0100 Subject: [PATCH 50/82] enable some MOI contlinear tests --- test/MOI_wrapper.jl | 26 +++++++++----------------- 1 file changed, 9 insertions(+), 17 deletions(-) diff --git a/test/MOI_wrapper.jl b/test/MOI_wrapper.jl index 5cb93209..b8c7882b 100644 --- a/test/MOI_wrapper.jl +++ b/test/MOI_wrapper.jl @@ -7,23 +7,15 @@ const config = MOIT.TestConfig(duals=false, infeas_certificates=false) @testset "MOI Continuous Linear" begin excluded = [ - "linear1", - "linear2", - "linear3", - "linear4", - "linear5", - "linear6", - "linear7", - "linear8a", - "linear8b", - "linear8c", - "linear9", - "linear10", - "linear11", - "linear12", - "linear13", - "linear14", - "linear15", + "linear1", # needs MOI.delete + "linear5", # needs MOI.delete + "linear7", # needs MOI.VectorAffineFunction + "linear8b", # TODO: have solutions for unbounded problem + "linear8c", # TODO: have solutions for unbounded problem + "linear11", # needs MOI.delete + "linear13", # TODO: support MOI.FEASIBILITY_SENSE + "linear14", # needs MOI.delete + "linear15", # needs MOI.VectorAffineFunction ] MOIT.contlineartest(optimizer, config, excluded) end From f4b71d8dbf35582ded760bfc251dd1fe3f5979e8 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 22:23:10 +0100 Subject: [PATCH 51/82] fix ResultCount for unbounded problems --- src/MOI_wrapper.jl | 8 +++++++- test/MOI_wrapper.jl | 2 -- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 40f48a61..19b86026 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -329,7 +329,13 @@ function MOI.get(o::Optimizer, ::MOI.PrimalStatus) SCIPgetNSols(get_scip(o)) > 0 ? MOI.FEASIBLE_POINT : MOI.NO_SOLUTION end -MOI.get(o::Optimizer, ::MOI.ResultCount) = SCIPgetNSols(get_scip(o)) +function MOI.get(o::Optimizer, ::MOI.ResultCount) + status = SCIPgetStatus(get_scip(o)) + if status in [SCIP_STATUS_UNBOUNDED, SCIP_STATUS_INFORUNBD] + return 0 + end + return SCIPgetNSols(get_scip(o)) +end function MOI.get(o::Optimizer, ::MOI.ObjectiveValue) scip = get_scip(o) diff --git a/test/MOI_wrapper.jl b/test/MOI_wrapper.jl index b8c7882b..7416cd9b 100644 --- a/test/MOI_wrapper.jl +++ b/test/MOI_wrapper.jl @@ -10,8 +10,6 @@ const config = MOIT.TestConfig(duals=false, infeas_certificates=false) "linear1", # needs MOI.delete "linear5", # needs MOI.delete "linear7", # needs MOI.VectorAffineFunction - "linear8b", # TODO: have solutions for unbounded problem - "linear8c", # TODO: have solutions for unbounded problem "linear11", # needs MOI.delete "linear13", # TODO: support MOI.FEASIBILITY_SENSE "linear14", # needs MOI.delete From 49494b494eec96bd03f97b6ec9493bbc8d8a2fa8 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 22:45:27 +0100 Subject: [PATCH 52/82] support basic, generic parameter setting --- src/MOI_wrapper.jl | 15 ++++++++++++++- src/managed_scip.jl | 6 ++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 19b86026..7b8a93ac 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -12,8 +12,9 @@ mutable struct Optimizer <: MOI.AbstractOptimizer mscip::ManagedSCIP var::VarMap cons::ConsMap + params::Dict{String,Any} - Optimizer() = new(ManagedSCIP(), VarMap(), ConsMap()) + Optimizer() = new(ManagedSCIP(), VarMap(), ConsMap(), Dict()) end @@ -96,6 +97,14 @@ MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = !copy_names +struct Param <: MOI.AbstractOptimizerAttribute + name::String +end +function MOI.set(o::Optimizer, param::Param, value) + o.params[param.name] = value + set_parameter(o.mscip, param.name, value) + return nothing +end ## model creation, query and modification @@ -111,6 +120,10 @@ function MOI.empty!(o::Optimizer) # clear auxiliary mapping structures o.var = VarMap() o.cons = ConsMap() + # reapply parameters + for pair in o.params + set_parameter(o.mscip, pair.first, pair.second) + end return nothing end diff --git a/src/managed_scip.jl b/src/managed_scip.jl index 18b9af7d..de484cf7 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -66,3 +66,9 @@ function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) # can't delete constraint, so we use the array position as index return length(mscip.conss) end + +"Set generic parameter" +function set_parameter(mscip::ManagedSCIP, name::String, value) + @SC SCIPsetParam(get_scip(mscip), name, Ptr{Cvoid}(value)) + return nothing +end From aa3d318572a660392067382468fc151fb9ac15d7 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 22:45:40 +0100 Subject: [PATCH 53/82] disable SCIP output for MOI tests --- test/MOI_wrapper.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/MOI_wrapper.jl b/test/MOI_wrapper.jl index 7416cd9b..e4580a98 100644 --- a/test/MOI_wrapper.jl +++ b/test/MOI_wrapper.jl @@ -3,6 +3,8 @@ const MOI = MathOptInterface const MOIT = MOI.Test const optimizer = SCIP.Optimizer() +MOI.set(optimizer, SCIP.Param("display/verblevel"), 0) + const config = MOIT.TestConfig(duals=false, infeas_certificates=false) @testset "MOI Continuous Linear" begin From f34c1d0d5ad9477380be2c2d4dc48c80b8044732 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 23:18:19 +0100 Subject: [PATCH 54/82] fix get(ConstraintPrimal, SingleVariable) --- src/MOI_wrapper.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 7b8a93ac..6c50b06b 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -362,7 +362,7 @@ end function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{MOI.SingleVariable,<:SS}) scip = get_scip(o) - return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, VI(ci.variable))) + return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, VI(ci.value))) end function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}) From 92d42b9286f36cb91ec7fe92fba936daecf89138 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 23:29:24 +0100 Subject: [PATCH 55/82] support problem and variable names --- src/MOI_wrapper.jl | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 6c50b06b..a6800cc0 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -95,7 +95,7 @@ MOI.supports_constraint(o::Optimizer, ::Type{<:SF}, ::Type{<:SS}) = true MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}) = true -MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = !copy_names +MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = true struct Param <: MOI.AbstractOptimizerAttribute name::String @@ -131,6 +131,9 @@ function MOI.copy_to(dest::Optimizer, src::MOI.ModelLike; kws...) MOIU.automatic_copy_to(dest, src; kws...) end +MOI.get(o::Optimizer, ::MOI.Name) = SCIPgetProbName(get_scip(o)) +MOI.set(o::Optimizer, ::MOI.Name, name::String) = @SC SCIPsetProbName(get_scip(o), name) + function MOI.add_variable(o::Optimizer) allow_modification(o) i::Int = add_variable(o.mscip) @@ -143,6 +146,16 @@ MOI.add_variables(o::Optimizer, n) = [MOI.add_variable(o) for i=1:n] MOI.get(o::Optimizer, ::MOI.NumberOfVariables) = length(o.mscip.vars) MOI.get(o::Optimizer, ::MOI.ListOfVariableIndices) = VI.(1:length(o.mscip.vars)) +MOI.get(o::Optimizer, ::MOI.VariableName, vi::VI) = SCIPvarGetName(get_var(o, vi)) +function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) + @SC SCIPchgVarName(get_scip(o), get_var(o, vi), name) +end + +function MOI.get(o::Optimizer, ::Type{VI}, name::String) + var = SCIPfindVar(get_scip(o), name) + return VI(o.var[var]) +end + function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, set::S) where S <: SS allow_modification(o) From a99be156b2ae6c01c6fa73c99fb9dfcf147e8651 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sat, 22 Dec 2018 23:49:33 +0100 Subject: [PATCH 56/82] support names for some constraints - but not for SingleVariable function (these are not really stored as SCIP_CONS) --- src/MOI_wrapper.jl | 47 ++++++++++++++++++++++++++++++---------------- 1 file changed, 31 insertions(+), 16 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index a6800cc0..c1bcf055 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -5,16 +5,16 @@ const MOIU = MOI.Utilities const VI = MOI.VariableIndex const CI = MOI.ConstraintIndex -const VarMap = Dict{Ptr{SCIP_VAR}, Int} -const ConsMap = Dict{Tuple{DataType, DataType}, Vector{Int}} +const PtrMap = Dict{Ptr{Cvoid}, Int} +const ConsTypeMap = Dict{Tuple{DataType, DataType}, Vector{Int}} mutable struct Optimizer <: MOI.AbstractOptimizer mscip::ManagedSCIP - var::VarMap - cons::ConsMap + index::PtrMap + constypes::ConsTypeMap params::Dict{String,Any} - Optimizer() = new(ManagedSCIP(), VarMap(), ConsMap(), Dict()) + Optimizer() = new(ManagedSCIP(), PtrMap(), ConsTypeMap(), Dict()) end @@ -26,8 +26,8 @@ get_scip(o::Optimizer) = get_scip(o.mscip) "Returns pointer to SCIP variable" get_var(o::Optimizer, v::VI) = get_var(o.mscip, v.value) -"Returns index of SCIP variable" -get_index(o::Optimizer, var::Ptr{SCIP_VAR}) = o.var[var] +"Returns index of SCIP variable/constraint" +get_index(o::Optimizer, var::Ptr{Cvoid}) = o.index[var] "Returns pointer to SCIP constraint" get_cons(o::Optimizer, c::CI{F,S}) where {F,S} = get_cons(o.mscip, c.value) @@ -55,17 +55,17 @@ end "Register variable in mapping" function register!(o::Optimizer, var::Ptr{SCIP_VAR}, index::Int) - @assert !haskey(o.var, var) - o.var[var] = index + @assert !haskey(o.index, var) + o.index[var] = index return index end "Register constraint in mapping" function register!(o::Optimizer, c::CI{F,S}) where {F,S} - if haskey(o.cons, (F, S)) - push!(o.cons[F,S], c.value) + if haskey(o.constypes, (F, S)) + push!(o.constypes[F,S], c.value) else - o.cons[F,S] = [c.value] + o.constypes[F,S] = [c.value] end return c end @@ -118,8 +118,8 @@ function MOI.empty!(o::Optimizer) # create a new one o.mscip = ManagedSCIP() # clear auxiliary mapping structures - o.var = VarMap() - o.cons = ConsMap() + o.index = PtrMap() + o.constypes = ConsTypeMap() # reapply parameters for pair in o.params set_parameter(o.mscip, pair.first, pair.second) @@ -153,7 +153,7 @@ end function MOI.get(o::Optimizer, ::Type{VI}, name::String) var = SCIPfindVar(get_scip(o), name) - return VI(o.var[var]) + return VI(o.index[var]) end function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, @@ -216,7 +216,7 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, end function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} - haskey(o.cons, (F, S)) ? length(o.cons[F, S]) : 0 + haskey(o.constypes, (F, S)) ? length(o.constypes[F, S]) : 0 end function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, @@ -251,6 +251,21 @@ function MOI.get(o::Optimizer, ::MOI.ConstraintSet, from_bounds(S, lhs, rhs) end +function MOI.get(o::Optimizer, ::MOI.ConstraintName, + ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}) + SCIPconsGetName(get_cons(o, ci)) +end + +function MOI.set(o::Optimizer, ::MOI.ConstraintName, + ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}, name::String) + @SC SCIPchgConsName(get_scip(o), get_cons(o, ci), name) +end + +function MOI.get(o::Optimizer, ::Type{CI{F,S}}, name::String) where {F<:MOI.ScalarAffineFunction{Float64},S<:SS} + cons = SCIPfindCons(get_scip(o), name) + return CI{F,S}(o.index[cons]) +end + function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, obj::MOI.ScalarAffineFunction{Float64}) From 3d92cfc1af81d196c064696c3fa6dadef6240996 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 23 Dec 2018 16:13:56 +0100 Subject: [PATCH 57/82] try to support names for SingleVariable constraints - also implement is_valid, for tests --- src/MOI_wrapper.jl | 54 +++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 49 insertions(+), 5 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index c1bcf055..71b1aab6 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -14,7 +14,12 @@ mutable struct Optimizer <: MOI.AbstractOptimizer constypes::ConsTypeMap params::Dict{String,Any} - Optimizer() = new(ManagedSCIP(), PtrMap(), ConsTypeMap(), Dict()) + # store names of constraints with SingleVariable function + sv2name::Dict{CI,String} + name2sv::Dict{String,CI} + + Optimizer() = new(ManagedSCIP(), PtrMap(), ConsTypeMap(), Dict(), + Dict(), Dict()) end @@ -120,6 +125,8 @@ function MOI.empty!(o::Optimizer) # clear auxiliary mapping structures o.index = PtrMap() o.constypes = ConsTypeMap() + o.sv2name = Dict() + o.name2sv = Dict() # reapply parameters for pair in o.params set_parameter(o.mscip, pair.first, pair.second) @@ -145,6 +152,7 @@ end MOI.add_variables(o::Optimizer, n) = [MOI.add_variable(o) for i=1:n] MOI.get(o::Optimizer, ::MOI.NumberOfVariables) = length(o.mscip.vars) MOI.get(o::Optimizer, ::MOI.ListOfVariableIndices) = VI.(1:length(o.mscip.vars)) +MOI.is_valid(o::Optimizer, vi::VI) = 1 <= vi.value <= length(o.mscip.vars) MOI.get(o::Optimizer, ::MOI.VariableName, vi::VI) = SCIPvarGetName(get_var(o, vi)) function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) @@ -152,8 +160,9 @@ function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) end function MOI.get(o::Optimizer, ::Type{VI}, name::String) + # TODO: make sure this is the original variable, not transformed? var = SCIPfindVar(get_scip(o), name) - return VI(o.index[var]) + return var == C_NULL ? nothing : VI(o.index[var]) end function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, @@ -178,6 +187,10 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, return nothing end +function MOI.is_valid(o::Optimizer, ci::CI{MOI.SingleVariable,<:SS}) + 1 <= ci.value <= length(o.mscip.vars) +end + function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64}, set::S) where {S <: SS} if func.constant != 0.0 @@ -196,7 +209,10 @@ function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64 rhs = rhs == nothing ? SCIPinfinity(scip) : rhs i = add_linear_constraint(o.mscip, varidx, coefs, lhs, rhs) - return register!(o, CI{MOI.ScalarAffineFunction{Float64}, S}(i)) + ci = CI{MOI.ScalarAffineFunction{Float64}, S}(i) + register!(o, ci) + register!(o, get_cons(o, ci), i) + return ci end function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, @@ -215,6 +231,10 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, return nothing end +function MOI.is_valid(o::Optimizer, ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}) + 1 <= ci.value <= length(o.mscip.cons) +end + function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} haskey(o.constypes, (F, S)) ? length(o.constypes[F, S]) : 0 end @@ -262,10 +282,34 @@ function MOI.set(o::Optimizer, ::MOI.ConstraintName, end function MOI.get(o::Optimizer, ::Type{CI{F,S}}, name::String) where {F<:MOI.ScalarAffineFunction{Float64},S<:SS} - cons = SCIPfindCons(get_scip(o), name) - return CI{F,S}(o.index[cons]) + cons = SCIPfindOrigCons(get_scip(o), name) + return cons == C_NULL ? nothing : CI{F,S}(o.index[cons]) +end + +function MOI.get(o::Optimizer, ::MOI.ConstraintName, + ci::CI{MOI.SingleVariable,<:SS}) + o.sv2name[ci] end +function MOI.set(o::Optimizer, ::MOI.ConstraintName, + ci::CI{MOI.SingleVariable,<:SS}, name::String) + # delete old reverse reference + if haskey(o.sv2name, ci) + delete!(o.name2sv, o.sv2name[ci]) + end + # set new name + o.sv2name[ci] = name + o.name2sv[name] = ci + return nothing +end + +function MOI.get(o::Optimizer, ::Type{CI{F,S}}, name::String) where {F<:MOI.SingleVariable,S<:SS} + o.name2sv[name] +end + +# for unsupported constraints +MOI.get(o::Optimizer, ::Type{CI}, name::String) = nothing + function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, obj::MOI.ScalarAffineFunction{Float64}) From ee976e776d88f04fb15e04b034843d2a44e8e6ea Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 23 Dec 2018 16:20:23 +0100 Subject: [PATCH 58/82] partially revert support for names - we only support what SCIP offers directly: - get/set name of problem - get/set name of variable by index - get/set name of (proper) constraints index - don't support names of SingleVariable constraints - are represented as variable bounds - would have to store names and reverse mapping separately - don't support getting index by name - don't want to keep track of duplicate names - have to be careful about original vs transformed problem --- src/MOI_wrapper.jl | 46 ++-------------------------------------------- 1 file changed, 2 insertions(+), 44 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 71b1aab6..2daccbf7 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -14,12 +14,7 @@ mutable struct Optimizer <: MOI.AbstractOptimizer constypes::ConsTypeMap params::Dict{String,Any} - # store names of constraints with SingleVariable function - sv2name::Dict{CI,String} - name2sv::Dict{String,CI} - - Optimizer() = new(ManagedSCIP(), PtrMap(), ConsTypeMap(), Dict(), - Dict(), Dict()) + Optimizer() = new(ManagedSCIP(), PtrMap(), ConsTypeMap(), Dict()) end @@ -100,7 +95,7 @@ MOI.supports_constraint(o::Optimizer, ::Type{<:SF}, ::Type{<:SS}) = true MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}) = true -MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = true +MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = !copy_names struct Param <: MOI.AbstractOptimizerAttribute name::String @@ -125,8 +120,6 @@ function MOI.empty!(o::Optimizer) # clear auxiliary mapping structures o.index = PtrMap() o.constypes = ConsTypeMap() - o.sv2name = Dict() - o.name2sv = Dict() # reapply parameters for pair in o.params set_parameter(o.mscip, pair.first, pair.second) @@ -159,12 +152,6 @@ function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) @SC SCIPchgVarName(get_scip(o), get_var(o, vi), name) end -function MOI.get(o::Optimizer, ::Type{VI}, name::String) - # TODO: make sure this is the original variable, not transformed? - var = SCIPfindVar(get_scip(o), name) - return var == C_NULL ? nothing : VI(o.index[var]) -end - function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, set::S) where S <: SS allow_modification(o) @@ -281,35 +268,6 @@ function MOI.set(o::Optimizer, ::MOI.ConstraintName, @SC SCIPchgConsName(get_scip(o), get_cons(o, ci), name) end -function MOI.get(o::Optimizer, ::Type{CI{F,S}}, name::String) where {F<:MOI.ScalarAffineFunction{Float64},S<:SS} - cons = SCIPfindOrigCons(get_scip(o), name) - return cons == C_NULL ? nothing : CI{F,S}(o.index[cons]) -end - -function MOI.get(o::Optimizer, ::MOI.ConstraintName, - ci::CI{MOI.SingleVariable,<:SS}) - o.sv2name[ci] -end - -function MOI.set(o::Optimizer, ::MOI.ConstraintName, - ci::CI{MOI.SingleVariable,<:SS}, name::String) - # delete old reverse reference - if haskey(o.sv2name, ci) - delete!(o.name2sv, o.sv2name[ci]) - end - # set new name - o.sv2name[ci] = name - o.name2sv[name] = ci - return nothing -end - -function MOI.get(o::Optimizer, ::Type{CI{F,S}}, name::String) where {F<:MOI.SingleVariable,S<:SS} - o.name2sv[name] -end - -# for unsupported constraints -MOI.get(o::Optimizer, ::Type{CI}, name::String) = nothing - function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, obj::MOI.ScalarAffineFunction{Float64}) From 110682c9d2bd02522e04dc59fc4eb426afd4de40 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 23 Dec 2018 18:14:31 +0100 Subject: [PATCH 59/82] use abbreviations for MOI types --- src/MOI_wrapper.jl | 126 ++++++++++++++++++++------------------------- 1 file changed, 55 insertions(+), 71 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 2daccbf7..84765351 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -2,8 +2,22 @@ using MathOptInterface const MOI = MathOptInterface const MOIU = MOI.Utilities +# indices const VI = MOI.VariableIndex const CI = MOI.ConstraintIndex +# supported functions +const SVF = MOI.SingleVariable +const SAF = MOI.ScalarAffineFunction{Float64} +# supported sets +const EQS = MOI.EqualTo{Float64} +const GTS = MOI.GreaterThan{Float64} +const LTS = MOI.LessThan{Float64} +const INS = MOI.Interval{Float64} +const BOUNDS = Union{EQS, GTS, LTS, INS} +# support changes +const SCC = MOI.ScalarCoefficientChange{Float64} +# other MOI types +const SAT = MOI.ScalarAffineTerm{Float64} const PtrMap = Dict{Ptr{Cvoid}, Int} const ConsTypeMap = Dict{Tuple{DataType, DataType}, Vector{Int}} @@ -33,25 +47,16 @@ get_index(o::Optimizer, var::Ptr{Cvoid}) = o.index[var] get_cons(o::Optimizer, c::CI{F,S}) where {F,S} = get_cons(o.mscip, c.value) "Extract bounds from sets" -bounds(set::MOI.EqualTo{Float64}) = (set.value, set.value) -bounds(set::MOI.GreaterThan{Float64}) = (set.lower, nothing) -bounds(set::MOI.LessThan{Float64}) = (nothing, set.upper) -bounds(set::MOI.Interval{Float64}) = (set.lower, set.upper) +bounds(set::EQS) = (set.value, set.value) +bounds(set::GTS) = (set.lower, nothing) +bounds(set::LTS) = (nothing, set.upper) +bounds(set::INS) = (set.lower, set.upper) "Make set from bounds" -function from_bounds(::Type{MOI.EqualTo{Float64}}, lower, upper) - @assert lower == upper - return MOI.EqualTo{Float64}(lower) -end -function from_bounds(::Type{MOI.GreaterThan{Float64}}, lower, upper) - MOI.GreaterThan{Float64}(lower) -end -function from_bounds(::Type{MOI.LessThan{Float64}}, lower, upper) - MOI.LessThan{Float64}(upper) -end -function from_bounds(::Type{MOI.Interval{Float64}}, lower, upper) - MOI.Interval{Float64}(lower, upper) -end +from_bounds(::Type{EQS}, lower, upper) = EQS(lower) # should == upper +from_bounds(::Type{GTS}, lower, upper) = GTS(lower) +from_bounds(::Type{LTS}, lower, upper) = LTS(upper) +from_bounds(::Type{INS}, lower, upper) = INS(lower, upper) "Register variable in mapping" function register!(o::Optimizer, var::Ptr{SCIP_VAR}, index::Int) @@ -83,17 +88,13 @@ end MOI.get(::Optimizer, ::MOI.SolverName) = "SCIP" -# support variable bounds and linear constraints -const SF = Union{MOI.SingleVariable, - MOI.ScalarAffineFunction{Float64}} -const SS = Union{MOI.EqualTo{Float64}, - MOI.GreaterThan{Float64}, - MOI.LessThan{Float64}, - MOI.Interval{Float64}} -MOI.supports_constraint(o::Optimizer, ::Type{<:SF}, ::Type{<:SS}) = true +# variable bounds +MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:BOUNDS}) = true +# linear constraints +MOI.supports_constraint(o::Optimizer, ::Type{SAF}, ::Type{<:BOUNDS}) = true MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true -MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}) = true +MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{SAF}) = true MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = !copy_names @@ -152,8 +153,7 @@ function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) @SC SCIPchgVarName(get_scip(o), get_var(o, vi), name) end -function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, - set::S) where S <: SS +function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: BOUNDS allow_modification(o) var = get_var(o, func.variable) lb, ub = bounds(set) @@ -161,11 +161,10 @@ function MOI.add_constraint(o::Optimizer, func::MOI.SingleVariable, ub == nothing || @SC SCIPchgVarUb(get_scip(o), var, ub) # use var index for cons index of this type i = func.variable.value - return register!(o, CI{MOI.SingleVariable, S}(i)) + return register!(o, CI{SVF, S}(i)) end -function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, - ci::CI{MOI.SingleVariable,S}, set::S) where {S <: SS} +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) where {S <: BOUNDS} allow_modification(o) var = get_var(o, VI(ci.value)) # cons index is actually var index lb, ub = bounds(set) @@ -174,15 +173,14 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, return nothing end -function MOI.is_valid(o::Optimizer, ci::CI{MOI.SingleVariable,<:SS}) +function MOI.is_valid(o::Optimizer, ci::CI{SVF,<:BOUNDS}) 1 <= ci.value <= length(o.mscip.vars) end -function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64}, - set::S) where {S <: SS} +function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: BOUNDS} if func.constant != 0.0 msg = "SCIP does not support linear constraints with a constant offset." - throw(MOI.AddConstraintNotAllowed{MOI.ScalarAffineFunction{Float64}, S}(msg)) + throw(MOI.AddConstraintNotAllowed{SAF, S}(msg)) end allow_modification(o) @@ -196,14 +194,13 @@ function MOI.add_constraint(o::Optimizer, func::MOI.ScalarAffineFunction{Float64 rhs = rhs == nothing ? SCIPinfinity(scip) : rhs i = add_linear_constraint(o.mscip, varidx, coefs, lhs, rhs) - ci = CI{MOI.ScalarAffineFunction{Float64}, S}(i) + ci = CI{SAF, S}(i) register!(o, ci) register!(o, get_cons(o, ci), i) return ci end -function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, - ci::CI{MOI.ScalarAffineFunction{Float64},S}, set::S) where {S <: SS} +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) where {S <: BOUNDS} allow_modification(o) scip = get_scip(o) cons = get_cons(o, ci) @@ -218,7 +215,7 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, return nothing end -function MOI.is_valid(o::Optimizer, ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}) +function MOI.is_valid(o::Optimizer, ci::CI{SAF,<:BOUNDS}) 1 <= ci.value <= length(o.mscip.cons) end @@ -226,51 +223,43 @@ function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} haskey(o.constypes, (F, S)) ? length(o.constypes[F, S]) : 0 end -function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, - ci::CI{MOI.SingleVariable, S}) where S <: SS - MOI.SingleVariable(ci) +function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SVF, S}) where S <: BOUNDS + SVF(ci) end -function MOI.get(o::Optimizer, ::MOI.ConstraintSet, - ci::CI{MOI.SingleVariable, S}) where S <: SS +function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SVF, S}) where S <: BOUNDS var = get_var(o.mscip, ci.value) lb, ub = SCIPvarGetLbOriginal(var), SCIPvarGetUbOriginal(var) from_bounds(S, lb, ub) end -function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, - ci::CI{MOI.ScalarAffineFunction{Float64}, S}) where S <: SS +function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S <: BOUNDS scip, cons = get_scip(o), get_cons(o, ci) nvars::Int = SCIPgetNVarsLinear(scip, cons) vars = unsafe_wrap(Array{Ptr{SCIP_VAR}}, SCIPgetVarsLinear(scip, cons), nvars) vals = unsafe_wrap(Array{Float64}, SCIPgetValsLinear(scip, cons), nvars) - terms = [MOI.ScalarAffineTerm{Float64}(vals[i], VI(get_index(o, vars[i]))) + terms = [SAT(vals[i], VI(get_index(o, vars[i]))) for i=1:nvars] # can not identify constant anymore (is merged with lhs,rhs) - return MOI.ScalarAffineFunction{Float64}(terms, 0.0) + return SAF(terms, 0.0) end -function MOI.get(o::Optimizer, ::MOI.ConstraintSet, - ci::CI{MOI.ScalarAffineFunction{Float64}, S}) where S <: SS +function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SAF, S}) where S <: BOUNDS scip, cons = get_scip(o), get_cons(o, ci) lhs, rhs = SCIPgetLhsLinear(scip, cons), SCIPgetRhsLinear(scip, cons) from_bounds(S, lhs, rhs) end -function MOI.get(o::Optimizer, ::MOI.ConstraintName, - ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}) +function MOI.get(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:BOUNDS}) SCIPconsGetName(get_cons(o, ci)) end -function MOI.set(o::Optimizer, ::MOI.ConstraintName, - ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}, name::String) +function MOI.set(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:BOUNDS}, name::String) @SC SCIPchgConsName(get_scip(o), get_cons(o, ci), name) end -function MOI.set(o::Optimizer, - ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, - obj::MOI.ScalarAffineFunction{Float64}) +function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, obj::SAF) allow_modification(o) scip = get_scip(o) @@ -292,20 +281,18 @@ function MOI.set(o::Optimizer, return nothing end -function MOI.get(o::Optimizer, - ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}) - terms = MOI.ScalarAffineTerm{Float64}[] +function MOI.get(o::Optimizer, ::MOI.ObjectiveFunction{SAF}) + terms = SAT[] for i = 1:length(o.mscip.vars) vi = VI(i) coef = SCIPvarGetObj(get_var(o, vi)) - coef == 0.0 || push!(terms, MOI.ScalarAffineTerm{Float64}(coef, vi)) + coef == 0.0 || push!(terms, SAT(coef, vi)) end constant = SCIPgetOrigObjoffset(get_scip(o)) - return MOI.ScalarAffineFunction{Float64}(terms, constant) + return SAF(terms, constant) end -function MOI.set(o::Optimizer, ::MOI.ObjectiveSense, - sense::MOI.OptimizationSense) +function MOI.set(o::Optimizer, ::MOI.ObjectiveSense, sense::MOI.OptimizationSense) allow_modification(o) if sense == MOI.MIN_SENSE @SC SCIPsetObjsense(get_scip(o), SCIP_OBJSENSE_MINIMIZE) @@ -321,17 +308,14 @@ function MOI.get(o::Optimizer, ::MOI.ObjectiveSense) MOI.MIN_SENSE end -function MOI.modify(o::Optimizer, ci::CI{MOI.ScalarAffineFunction{Float64}, <:SS}, - change::MOI.ScalarCoefficientChange{Float64}) +function MOI.modify(o::Optimizer, ci::CI{SAF, <:BOUNDS}, change::SCC) allow_modification(o) @SC SCIPchgCoefLinear(get_scip(o), get_cons(o, ci), get_var(o, change.variable), change.new_coefficient) return nothing end -function MOI.modify(o::Optimizer, - ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}, - change::MOI.ScalarCoefficientChange{Float64}) +function MOI.modify(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, change::SCC) allow_modification(o) @SC SCIPchgVarObj(get_scip(o), get_var(o, change.variable), change.new_coefficient) @@ -390,12 +374,12 @@ function MOI.get(o::Optimizer, ::MOI.VariablePrimal, vi::VI) return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, vi)) end -function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{MOI.SingleVariable,<:SS}) +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SVF,<:BOUNDS}) scip = get_scip(o) return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, VI(ci.value))) end -function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{MOI.ScalarAffineFunction{Float64},<:SS}) +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SAF,<:BOUNDS}) scip = get_scip(o) return SCIPgetActivityLinear(scip, get_cons(o, ci), SCIPgetBestSol(scip)) end From acecde3e68c41224f639cb83dce4dd2263fe3440 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 23 Dec 2018 18:53:08 +0100 Subject: [PATCH 60/82] support variable types binary, integer --- src/MOI_wrapper.jl | 23 +++++++++++++++++++++++ src/wrapper/manual_commons.jl | 3 +++ 2 files changed, 26 insertions(+) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 84765351..c88d3b96 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -14,6 +14,9 @@ const GTS = MOI.GreaterThan{Float64} const LTS = MOI.LessThan{Float64} const INS = MOI.Interval{Float64} const BOUNDS = Union{EQS, GTS, LTS, INS} +const BINS = MOI.ZeroOne +const INTS = MOI.Integer +const TYPES = Union{BINS, INTS} # support changes const SCC = MOI.ScalarCoefficientChange{Float64} # other MOI types @@ -90,6 +93,8 @@ MOI.get(::Optimizer, ::MOI.SolverName) = "SCIP" # variable bounds MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:BOUNDS}) = true +# variable types (binary, integer) +MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:TYPES}) = true # linear constraints MOI.supports_constraint(o::Optimizer, ::Type{SAF}, ::Type{<:BOUNDS}) = true @@ -153,6 +158,24 @@ function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) @SC SCIPchgVarName(get_scip(o), get_var(o, vi), name) end +scip_vartype(::Type{BINS}) = SCIP_VARTYPE_BINARY +scip_vartype(::Type{INTS}) = SCIP_VARTYPE_INTEGER +function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where {S <: TYPES} + allow_modification(o) + scip = get_scip(o) + var = get_var(o, func.variable) + infeasible = Ref{Ptr{SCIP_Bool}} + @SC SCIPchgVarType(scip, var, scip_vartype(S), infeasible[]) + if S <: BINS + # need to adjust bounds for SCIP?! + @SC SCIPchgVarLb(scip, var, 0.0) + @SC SCIPchgVarUb(scip, var, 1.0) + end + # use var index for cons index of this type + i = func.variable.value + return register!(o, CI{SVF, S}(i)) +end + function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: BOUNDS allow_modification(o) var = get_var(o, func.variable) diff --git a/src/wrapper/manual_commons.jl b/src/wrapper/manual_commons.jl index fdc84b1c..96107337 100644 --- a/src/wrapper/manual_commons.jl +++ b/src/wrapper/manual_commons.jl @@ -41,3 +41,6 @@ const FILE = Cvoid const BMS_BLKMEM = Cvoid const BMS_BUFMEM = Cvoid + +const SCIP_Bool = Cuint +const SCIP_Real = Cdouble From 97a21087ff295383a11de72f3f48687849e69830 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 23 Dec 2018 21:15:12 +0100 Subject: [PATCH 61/82] add more solve statistics --- src/MOI_wrapper.jl | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index c88d3b96..b0bc69b6 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -406,3 +406,9 @@ function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SAF,<:BOUNDS}) scip = get_scip(o) return SCIPgetActivityLinear(scip, get_cons(o, ci), SCIPgetBestSol(scip)) end + +MOI.get(o::Optimizer, ::MOI.ObjectiveBound) = SCIPgetDualbound(get_scip(o)) +MOI.get(o::Optimizer, ::MOI.RelativeGap) = SCIPgetGap(get_scip(o)) +MOI.get(o::Optimizer, ::MOI.SolveTime) = SCIPgetSolvingTime(get_scip(o)) +MOI.get(o::Optimizer, ::MOI.SimplexIterations) = SCIPgetNLPIterations(get_scip(o)) +MOI.get(o::Optimizer, ::MOI.NodeCount) = SCIPgetNNodes(get_scip(o)) From b3ef38d596334e43da69528cedaaa7281aaf7e74 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 23 Dec 2018 21:15:33 +0100 Subject: [PATCH 62/82] enable some intlineartests --- test/MOI_wrapper.jl | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/MOI_wrapper.jl b/test/MOI_wrapper.jl index e4580a98..4b829682 100644 --- a/test/MOI_wrapper.jl +++ b/test/MOI_wrapper.jl @@ -19,3 +19,10 @@ const config = MOIT.TestConfig(duals=false, infeas_certificates=false) ] MOIT.contlineartest(optimizer, config, excluded) end + +@testset "MOI Integer Linear" begin + excluded = [ + "int2", # TODO: implement SOS1, SOS2 + ] + MOIT.intlineartest(optimizer, config, excluded) +end From e1821f13f53237799cb55429c1ca64a1c25f65d9 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 23 Dec 2018 22:18:05 +0100 Subject: [PATCH 63/82] update README --- README.md | 93 +++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 84 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index bf62b12a..91731960 100644 --- a/README.md +++ b/README.md @@ -1,16 +1,91 @@ # SCIP.jl + Julia interface to [SCIP](http://scip.zib.de) solver. [![Build Status](https://travis-ci.org/SCIP-Interfaces/SCIP.jl.svg?branch=master)](https://travis-ci.org/SCIP-Interfaces/SCIP.jl) [![Coverage Status](https://coveralls.io/repos/github/SCIP-Interfaces/SCIP.jl/badge.svg?branch=master)](https://coveralls.io/github/SCIP-Interfaces/SCIP.jl?branch=master) [![codecov](https://codecov.io/gh/SCIP-Interfaces/SCIP.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/SCIP-Interfaces/SCIP.jl) -This is a complete rewrite. We use -[Clang.jl](https://github.com/ihnorton/Clang.jl) to generate wrappers based on -the headers of the SCIP library. We aim to support -[JuMP](https://github.com/JuliaOpt/JuMP.jl) through -[MathOptInterface](https://github.com/JuliaOpt/MathOptInterface.jl). In this -first pass, only the -[LinQuadOptInterface](https://github.com/JuliaOpt/LinQuadOptInterface.jl) will -be implemented. This means that we will have a feature loss in the areas of -general nonlinear constraints as well as supported callbacks. +## Update (December 2018) + +We have completely rewritten the interface from scratch, +using[Clang.jl](https://github.com/ihnorton/Clang.jl) to generate wrappers based +on the headers of the SCIP library. +The goal is to support [JuMP](https://github.com/JuliaOpt/JuMP.jl) (from version +0.19 on) through +[MathOptInterface](https://github.com/JuliaOpt/MathOptInterface.jl). + +Currently, we support LP and MIP problems only. +This means we still have a feature loss in the areas as nonlinear constraints as +well as supported callbacks compared to previous versions (see below). + +## Getting Started + +To use SCIP.jl, you will need [SCIP](http://scip.zib.de) installed on your +system. [SCIP's license](https://scip.zib.de/index.php#license) does not allow +(automatic) redistribution, so please +[download](https://scip.zib.de/index.php#download) and install it yourself. + +Only Linux is tested and officially supported. Contributions to supporting other +operating systems are welcome. + +We recommend using one of the provided installers, e.g., +`SCIPOptSuite-6.0.0-Linux.deb` for systems based on Debian. Adding the SCIP.jl +package should then work out of the box: + + pkg> add SCIP + +If you [build SCIP from source])(https://scip.zib.de/doc-6.0.0/html/CMAKE.php) +you should set the environment variable `SCIPOPTDIR` to point the the +**installation path**. That is, `$SCIPOPTDIR/lib/libscip.so` should exist. + +## Design Considerations + +**Wrapper of Public API**: All of SCIP's public API methods are wrapped and +available within the `SCIP` package. This includes the `scip_*.h` and `pub_*.h` +headers that are collected in `scip.h`, as well as all default constraint +handlers (`cons_*`.) But the wrapped functions do not transform any data +structures and work on the *raw* points (e.g. `SCIP*`). Convenience wrapper +functions based on Julia types are added as needed. + +**Memory Management**: Programming with SCIP requires dealing with variable and +constraints objects that use [reference +counting](https://scip.zib.de/doc-6.0.0/html/OBJ.php) for memory management. +SCIP.jl provides a wrapper type `ManagedSCIP` that collects lists of `SCIP_VAR*` +and `SCIP_CONS*` under the hood, and releases all reference when it is garbage +collected itself (via `finalize`). When adding a variable (`add_variable`) or a +constraint (`add_linear_constraint`), an integer index is returned. This index +can be used to retrieve the `SCIP_VAR*` or `SCIP_CONS*` pointer via `get_var` +and `get_cons` respectively. + +`ManagedSCIP` does not currently support deletion of variables or constraints. + +**Supported Features for MathOptInterface**: We aim at exposing many of SCIP's +features through MathOptInterface. However, the focus is on keeping the wrapper +simple and avoiding duplicate storage of model data. + +As a consequence, we do not currently support some features such as retrieving +constraints by name (`SingleVariable`-set constraints are not stored as SCIP +constraints explicitly). + +Support for more constraint types (quadratic/SOC, SOS1/2, nonlinear expression) +is planned, but SCIP itself only supports affine objective functions, so we will +stick with that. More general objective functions could be implented via a +[bridge](https://github.com/JuliaOpt/MathOptInterface.jl/issues/529). + +## Old Interface Implementation + +A previous implementation of SCIP.jl supported +[JuMP](https://github.com/JuliaOpt/JuMP.jl) (up to version 0.18) through +[MathProgBase](https://github.com/JuliaOpt/MathOptInterface.jl). It did not +interface SCIP directly, but went through +[CSIP](https://github.com/SCIP-Interfaces/CSIP), a simplified C wrapper. + +Back then, the interface support MINLP problems as well as solver-indepentent +callbacks for lazy constraints and heuristics. + +To use that version, you need to pin the version of SCIP.jl to `v0.6.1` (the +last release before the rewrite): + + pkg> add SCIP@v0.6.1 + pkg> pin SCIP From 7e4054b185b360ff428e0de1f7985906137ee57e Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 23 Dec 2018 22:26:05 +0100 Subject: [PATCH 64/82] README: fix typos --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 91731960..a8874e63 100644 --- a/README.md +++ b/README.md @@ -8,9 +8,9 @@ Julia interface to [SCIP](http://scip.zib.de) solver. ## Update (December 2018) -We have completely rewritten the interface from scratch, -using[Clang.jl](https://github.com/ihnorton/Clang.jl) to generate wrappers based -on the headers of the SCIP library. +We have completely rewritten the interface from scratch, using +[Clang.jl](https://github.com/ihnorton/Clang.jl) to generate wrappers based on +the headers of the SCIP library. The goal is to support [JuMP](https://github.com/JuliaOpt/JuMP.jl) (from version 0.19 on) through [MathOptInterface](https://github.com/JuliaOpt/MathOptInterface.jl). @@ -35,7 +35,7 @@ package should then work out of the box: pkg> add SCIP -If you [build SCIP from source])(https://scip.zib.de/doc-6.0.0/html/CMAKE.php) +If you [build SCIP from source](https://scip.zib.de/doc-6.0.0/html/CMAKE.php) you should set the environment variable `SCIPOPTDIR` to point the the **installation path**. That is, `$SCIPOPTDIR/lib/libscip.so` should exist. @@ -44,7 +44,7 @@ you should set the environment variable `SCIPOPTDIR` to point the the **Wrapper of Public API**: All of SCIP's public API methods are wrapped and available within the `SCIP` package. This includes the `scip_*.h` and `pub_*.h` headers that are collected in `scip.h`, as well as all default constraint -handlers (`cons_*`.) But the wrapped functions do not transform any data +handlers (`cons_*.h`.) But the wrapped functions do not transform any data structures and work on the *raw* points (e.g. `SCIP*`). Convenience wrapper functions based on Julia types are added as needed. From 279fae4a47fd7a1c681c40a03e069bddc7274ee2 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 4 Jan 2019 17:18:12 +0100 Subject: [PATCH 65/82] README: fix typo, more detail about pointer types --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index a8874e63..3c035233 100644 --- a/README.md +++ b/README.md @@ -45,8 +45,8 @@ you should set the environment variable `SCIPOPTDIR` to point the the available within the `SCIP` package. This includes the `scip_*.h` and `pub_*.h` headers that are collected in `scip.h`, as well as all default constraint handlers (`cons_*.h`.) But the wrapped functions do not transform any data -structures and work on the *raw* points (e.g. `SCIP*`). Convenience wrapper -functions based on Julia types are added as needed. +structures and work on the *raw* pointers (e.g. `SCIP*` in C, `Ptr{SCIP_}` in +Julia). Convenience wrapper functions based on Julia types are added as needed. **Memory Management**: Programming with SCIP requires dealing with variable and constraints objects that use [reference From c5d54e371659910c5023c3fccb9da857af3adda4 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 4 Jan 2019 17:26:36 +0100 Subject: [PATCH 66/82] add dummy SCIPSolver() to warn old users about MPB/MOI. --- src/SCIP.jl | 3 +++ src/compat.jl | 7 +++++++ 2 files changed, 10 insertions(+) create mode 100644 src/compat.jl diff --git a/src/SCIP.jl b/src/SCIP.jl index a34a953c..16c4b1c4 100644 --- a/src/SCIP.jl +++ b/src/SCIP.jl @@ -27,4 +27,7 @@ include("managed_scip.jl") # implementation of MOI include("MOI_wrapper.jl") +# warn about rewrite +include("compat.jl") + end diff --git a/src/compat.jl b/src/compat.jl new file mode 100644 index 00000000..b8ac4ddb --- /dev/null +++ b/src/compat.jl @@ -0,0 +1,7 @@ +export SCIPSolver + +# dummy implementation to tell users about transition to MathOptInterface +function SCIPSolver(args...; kwargs...) + error("Support for MathProgBase was dropped. " * + "Please downgrade to v0.6.1, see README for details.") +end From 5f5d2c1f66d3b89ff8d86faca8bc2d3d04fc049b Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 4 Jan 2019 17:30:33 +0100 Subject: [PATCH 67/82] rm dependency on Compat --- REQUIRE | 1 - deps/build.jl | 3 +-- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/REQUIRE b/REQUIRE index 357da5a0..8d3c0c00 100644 --- a/REQUIRE +++ b/REQUIRE @@ -1,3 +1,2 @@ julia 1.0 -Compat MathOptInterface 0.8 diff --git a/deps/build.jl b/deps/build.jl index 0c5bff06..91405dfe 100644 --- a/deps/build.jl +++ b/deps/build.jl @@ -1,4 +1,3 @@ -using Compat using Libdl depsfile = joinpath(dirname(@__FILE__), "deps.jl") @@ -17,7 +16,7 @@ paths_to_try = [] # prefer environment variable if haskey(ENV, "SCIPOPTDIR") - if Compat.Sys.isunix() + if Sys.islinux() push!(paths_to_try, joinpath(ENV["SCIPOPTDIR"], "lib", libname)) end end From cb51e3d7b40d87c8eff0dede80e02f724a8e3c7e Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 4 Jan 2019 17:38:05 +0100 Subject: [PATCH 68/82] add version check agains upper bound (next major) --- src/SCIP.jl | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/SCIP.jl b/src/SCIP.jl index 16c4b1c4..62d40da8 100644 --- a/src/SCIP.jl +++ b/src/SCIP.jl @@ -13,8 +13,10 @@ function __init__() patch = SCIPtechVersion() current = VersionNumber("$major.$minor.$patch") required = VersionNumber("6.0.0") - if current < required - error("SCIP is installed at version $current, need $required or newer.") + upperbound = VersionNumber(required.major + 1) + if current < required || current >= upperbound + error("SCIP is installed at version $current, " * + "supported are $required up to $upperbound.") end end From b4e75297beee8e2d1fe28127f3a88dc67dff2825 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 4 Jan 2019 17:48:00 +0100 Subject: [PATCH 69/82] documentation formatting --- src/MOI_wrapper.jl | 16 ++++++++-------- src/managed_scip.jl | 14 +++++++------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index b0bc69b6..90f0e555 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -37,38 +37,38 @@ end ## convenience functions (not part of MOI) -"Returns pointer to SCIP instance" +"Return pointer to SCIP instance." get_scip(o::Optimizer) = get_scip(o.mscip) -"Returns pointer to SCIP variable" +"Return pointer to SCIP variable." get_var(o::Optimizer, v::VI) = get_var(o.mscip, v.value) -"Returns index of SCIP variable/constraint" +"Return index of SCIP variable/constraint." get_index(o::Optimizer, var::Ptr{Cvoid}) = o.index[var] -"Returns pointer to SCIP constraint" +"Return pointer to SCIP constraint." get_cons(o::Optimizer, c::CI{F,S}) where {F,S} = get_cons(o.mscip, c.value) -"Extract bounds from sets" +"Extract bounds from sets." bounds(set::EQS) = (set.value, set.value) bounds(set::GTS) = (set.lower, nothing) bounds(set::LTS) = (nothing, set.upper) bounds(set::INS) = (set.lower, set.upper) -"Make set from bounds" +"Make set from bounds." from_bounds(::Type{EQS}, lower, upper) = EQS(lower) # should == upper from_bounds(::Type{GTS}, lower, upper) = GTS(lower) from_bounds(::Type{LTS}, lower, upper) = LTS(upper) from_bounds(::Type{INS}, lower, upper) = INS(lower, upper) -"Register variable in mapping" +"Register variable in mapping." function register!(o::Optimizer, var::Ptr{SCIP_VAR}, index::Int) @assert !haskey(o.index, var) o.index[var] = index return index end -"Register constraint in mapping" +"Register constraint in mapping." function register!(o::Optimizer, c::CI{F,S}) where {F,S} if haskey(o.constypes, (F, S)) push!(o.constypes[F,S], c.value) diff --git a/src/managed_scip.jl b/src/managed_scip.jl index de484cf7..f7ebca70 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -1,4 +1,4 @@ -# holds pointers to SCIP data and takes care of memory mgmt +"ManagedSCIP holds pointers to SCIP data and takes care of memory management." mutable struct ManagedSCIP scip::Ref{Ptr{SCIP_}} vars::Vector{Ref{Ptr{SCIP_VAR}}} @@ -16,7 +16,7 @@ mutable struct ManagedSCIP end end -"Release references and free memory" +"Release references and free memory." function free_scip(mscip::ManagedSCIP) # avoid double-free if mscip.scip[] != C_NULL @@ -31,13 +31,13 @@ function free_scip(mscip::ManagedSCIP) @assert mscip.scip[] == C_NULL end -"Returns pointer to SCIP instance" +"Return pointer to SCIP instance." get_scip(mscip::ManagedSCIP) = mscip.scip[] -"Returns pointer to SCIP variable" +"Return pointer to SCIP variable." get_var(mscip::ManagedSCIP, i::Int) = mscip.vars[i][] -"Returns pointer to SCIP constraint" +"Return pointer to SCIP constraint." get_cons(mscip::ManagedSCIP, i::Int) = mscip.conss[i][] "Add variable to problem (continuous, no bounds)" @@ -53,7 +53,7 @@ function add_variable(mscip::ManagedSCIP) return length(mscip.vars) end -"Add (ranged) linear constraint to problem" +"Add (ranged) linear constraint to problem." function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) @assert length(varidx) == length(coeffs) vars = [get_var(mscip, i) for i in varidx] @@ -67,7 +67,7 @@ function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) return length(mscip.conss) end -"Set generic parameter" +"Set generic parameter." function set_parameter(mscip::ManagedSCIP, name::String, value) @SC SCIPsetParam(get_scip(mscip), name, Ptr{Cvoid}(value)) return nothing From 881b9a771b883d71f310e50042c82f7d9f026311 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Fri, 4 Jan 2019 17:53:01 +0100 Subject: [PATCH 70/82] added documentation --- src/MOI_wrapper.jl | 4 ++-- src/managed_scip.jl | 16 +++++++++++++--- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 90f0e555..21fb9dd4 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -61,14 +61,14 @@ from_bounds(::Type{GTS}, lower, upper) = GTS(lower) from_bounds(::Type{LTS}, lower, upper) = LTS(upper) from_bounds(::Type{INS}, lower, upper) = INS(lower, upper) -"Register variable in mapping." +"Register variable in mapping, return variable index." function register!(o::Optimizer, var::Ptr{SCIP_VAR}, index::Int) @assert !haskey(o.index, var) o.index[var] = index return index end -"Register constraint in mapping." +"Register constraint in mapping, return constraint index." function register!(o::Optimizer, c::CI{F,S}) where {F,S} if haskey(o.constypes, (F, S)) push!(o.constypes[F,S], c.value) diff --git a/src/managed_scip.jl b/src/managed_scip.jl index f7ebca70..a6694a57 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -18,7 +18,7 @@ end "Release references and free memory." function free_scip(mscip::ManagedSCIP) - # avoid double-free + # Avoid double-free (SCIP will set the pointers to NULL). if mscip.scip[] != C_NULL for cons in mscip.conss @SC SCIPreleaseCons(mscip.scip[], cons) @@ -40,7 +40,7 @@ get_var(mscip::ManagedSCIP, i::Int) = mscip.vars[i][] "Return pointer to SCIP constraint." get_cons(mscip::ManagedSCIP, i::Int) = mscip.conss[i][] -"Add variable to problem (continuous, no bounds)" +"Add variable to problem (continuous, no bounds), return variable index." function add_variable(mscip::ManagedSCIP) var = Ref{Ptr{SCIP_VAR}}() @SC rc = SCIPcreateVarBasic( @@ -53,7 +53,17 @@ function add_variable(mscip::ManagedSCIP) return length(mscip.vars) end -"Add (ranged) linear constraint to problem." +""" +Add (ranged) linear constraint to problem, return constraint index. + +# Arguments +- `varidx::AbstractArray{Int}`: indices of variables for affine terms. +- `coeffs::AbstractArray{Float64}`: coefficients for affine terms. +- `lhs::Float64`: left-hand side for ranged constraint +- `rhs::Float64`: right-hand side for ranged constraint + +Use `(-)SCIPinfinity(scip)` for one of the bounds if not applicable. +""" function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) @assert length(varidx) == length(coeffs) vars = [get_var(mscip, i) for i in varidx] From d098f1084ee66e5d6b81fab35bf5d2ef2d84ff63 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 11:46:14 +0100 Subject: [PATCH 71/82] use get_* functions more --- src/MOI_wrapper.jl | 2 +- src/managed_scip.jl | 21 ++++++++++++--------- 2 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 21fb9dd4..34c9e98c 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -348,7 +348,7 @@ end ## optimization and results function MOI.optimize!(o::Optimizer) - @SC SCIPsolve(o.mscip.scip[]) + @SC SCIPsolve(get_scip(o)) return nothing end diff --git a/src/managed_scip.jl b/src/managed_scip.jl index a6694a57..5a0abf93 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -19,16 +19,17 @@ end "Release references and free memory." function free_scip(mscip::ManagedSCIP) # Avoid double-free (SCIP will set the pointers to NULL). - if mscip.scip[] != C_NULL + scip = get_scip(mscip) + if scip != C_NULL for cons in mscip.conss - @SC SCIPreleaseCons(mscip.scip[], cons) + @SC SCIPreleaseCons(scip, cons) end for var in mscip.vars - @SC SCIPreleaseVar(mscip.scip[], var) + @SC SCIPreleaseVar(scip, var) end @SC SCIPfree(mscip.scip) end - @assert mscip.scip[] == C_NULL + @assert get_scip(mscip) == C_NULL end "Return pointer to SCIP instance." @@ -42,11 +43,12 @@ get_cons(mscip::ManagedSCIP, i::Int) = mscip.conss[i][] "Add variable to problem (continuous, no bounds), return variable index." function add_variable(mscip::ManagedSCIP) + scip = get_scip(mscip) var = Ref{Ptr{SCIP_VAR}}() @SC rc = SCIPcreateVarBasic( - mscip.scip[], var, "", -SCIPinfinity(mscip.scip[]), - SCIPinfinity(mscip.scip[]), 0.0, SCIP_VARTYPE_CONTINUOUS) - @SC rc = SCIPaddVar(mscip.scip[], var[]) + scip, var, "", -SCIPinfinity(scip), + SCIPinfinity(scip), 0.0, SCIP_VARTYPE_CONTINUOUS) + @SC rc = SCIPaddVar(scip, var[]) push!(mscip.vars, var) # can't delete variable, so we use the array position as index @@ -66,11 +68,12 @@ Use `(-)SCIPinfinity(scip)` for one of the bounds if not applicable. """ function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) @assert length(varidx) == length(coeffs) + scip = get_scip(mscip) vars = [get_var(mscip, i) for i in varidx] cons = Ref{Ptr{SCIP_CONS}}() @SC rc = SCIPcreateConsBasicLinear( - mscip.scip[], cons, "", length(vars), vars, coeffs, lhs, rhs) - @SC rc = SCIPaddCons(mscip.scip[], cons[]) + scip, cons, "", length(vars), vars, coeffs, lhs, rhs) + @SC rc = SCIPaddCons(scip, cons[]) push!(mscip.conss, cons) # can't delete constraint, so we use the array position as index From d7c20e0b973f39b82b1e711197b70028b4eae3f0 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 12:05:05 +0100 Subject: [PATCH 72/82] rm get_ prefix for accessor functions --- src/MOI_wrapper.jl | 137 +++++++++++++++++++++----------------------- src/managed_scip.jl | 42 +++++++------- 2 files changed, 84 insertions(+), 95 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 34c9e98c..27ca7b86 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -38,16 +38,16 @@ end ## convenience functions (not part of MOI) "Return pointer to SCIP instance." -get_scip(o::Optimizer) = get_scip(o.mscip) +scip(o::Optimizer) = scip(o.mscip) "Return pointer to SCIP variable." -get_var(o::Optimizer, v::VI) = get_var(o.mscip, v.value) +var(o::Optimizer, v::VI) = var(o.mscip, v.value) "Return index of SCIP variable/constraint." get_index(o::Optimizer, var::Ptr{Cvoid}) = o.index[var] "Return pointer to SCIP constraint." -get_cons(o::Optimizer, c::CI{F,S}) where {F,S} = get_cons(o.mscip, c.value) +cons(o::Optimizer, c::CI{F,S}) where {F,S} = cons(o.mscip, c.value) "Extract bounds from sets." bounds(set::EQS) = (set.value, set.value) @@ -80,9 +80,8 @@ end "Go back from solved stage to problem modification stage, invalidating results." function allow_modification(o::Optimizer) - scip = get_scip(o) - if SCIPgetStage(scip) != SCIP_STAGE_PROBLEM - @SC SCIPfreeTransform(scip) + if SCIPgetStage(scip(o)) != SCIP_STAGE_PROBLEM + @SC SCIPfreeTransform(scip(o)) end return nothing end @@ -137,8 +136,8 @@ function MOI.copy_to(dest::Optimizer, src::MOI.ModelLike; kws...) MOIU.automatic_copy_to(dest, src; kws...) end -MOI.get(o::Optimizer, ::MOI.Name) = SCIPgetProbName(get_scip(o)) -MOI.set(o::Optimizer, ::MOI.Name, name::String) = @SC SCIPsetProbName(get_scip(o), name) +MOI.get(o::Optimizer, ::MOI.Name) = SCIPgetProbName(scip(o)) +MOI.set(o::Optimizer, ::MOI.Name, name::String) = @SC SCIPsetProbName(scip(o), name) function MOI.add_variable(o::Optimizer) allow_modification(o) @@ -153,23 +152,22 @@ MOI.get(o::Optimizer, ::MOI.NumberOfVariables) = length(o.mscip.vars) MOI.get(o::Optimizer, ::MOI.ListOfVariableIndices) = VI.(1:length(o.mscip.vars)) MOI.is_valid(o::Optimizer, vi::VI) = 1 <= vi.value <= length(o.mscip.vars) -MOI.get(o::Optimizer, ::MOI.VariableName, vi::VI) = SCIPvarGetName(get_var(o, vi)) +MOI.get(o::Optimizer, ::MOI.VariableName, vi::VI) = SCIPvarGetName(var(o, vi)) function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) - @SC SCIPchgVarName(get_scip(o), get_var(o, vi), name) + @SC SCIPchgVarName(scip(o), var(o, vi), name) end scip_vartype(::Type{BINS}) = SCIP_VARTYPE_BINARY scip_vartype(::Type{INTS}) = SCIP_VARTYPE_INTEGER function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where {S <: TYPES} allow_modification(o) - scip = get_scip(o) - var = get_var(o, func.variable) + v = var(o, func.variable) infeasible = Ref{Ptr{SCIP_Bool}} - @SC SCIPchgVarType(scip, var, scip_vartype(S), infeasible[]) + @SC SCIPchgVarType(scip(o), v, scip_vartype(S), infeasible[]) if S <: BINS # need to adjust bounds for SCIP?! - @SC SCIPchgVarLb(scip, var, 0.0) - @SC SCIPchgVarUb(scip, var, 1.0) + @SC SCIPchgVarLb(scip(o), v, 0.0) + @SC SCIPchgVarUb(scip(o), v, 1.0) end # use var index for cons index of this type i = func.variable.value @@ -178,10 +176,10 @@ end function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: BOUNDS allow_modification(o) - var = get_var(o, func.variable) + v = var(o, func.variable) lb, ub = bounds(set) - lb == nothing || @SC SCIPchgVarLb(get_scip(o), var, lb) - ub == nothing || @SC SCIPchgVarUb(get_scip(o), var, ub) + lb == nothing || @SC SCIPchgVarLb(scip(o), v, lb) + ub == nothing || @SC SCIPchgVarUb(scip(o), v, ub) # use var index for cons index of this type i = func.variable.value return register!(o, CI{SVF, S}(i)) @@ -189,10 +187,10 @@ end function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) where {S <: BOUNDS} allow_modification(o) - var = get_var(o, VI(ci.value)) # cons index is actually var index + v = var(o, VI(ci.value)) # cons index is actually var index lb, ub = bounds(set) - lb == nothing || @SC SCIPchgVarLb(get_scip(o), var, lb) - ub == nothing || @SC SCIPchgVarUb(get_scip(o), var, ub) + lb == nothing || @SC SCIPchgVarLb(scip(o), v, lb) + ub == nothing || @SC SCIPchgVarUb(scip(o), v, ub) return nothing end @@ -207,33 +205,30 @@ function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: BOUNDS} end allow_modification(o) - scip = get_scip(o) varidx = [t.variable_index.value for t in func.terms] coefs = [t.coefficient for t in func.terms] lhs, rhs = bounds(set) - lhs = lhs == nothing ? -SCIPinfinity(scip) : lhs - rhs = rhs == nothing ? SCIPinfinity(scip) : rhs + lhs = lhs == nothing ? -SCIPinfinity(scip(o)) : lhs + rhs = rhs == nothing ? SCIPinfinity(scip(o)) : rhs i = add_linear_constraint(o.mscip, varidx, coefs, lhs, rhs) ci = CI{SAF, S}(i) register!(o, ci) - register!(o, get_cons(o, ci), i) + register!(o, cons(o, ci), i) return ci end function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) where {S <: BOUNDS} allow_modification(o) - scip = get_scip(o) - cons = get_cons(o, ci) lhs, rhs = bounds(set) - lhs = lhs == nothing ? -SCIPinfinity(scip) : lhs - rhs = rhs == nothing ? SCIPinfinity(scip) : rhs + lhs = lhs == nothing ? -SCIPinfinity(scip(o)) : lhs + rhs = rhs == nothing ? SCIPinfinity(scip(o)) : rhs - @SC SCIPchgLhsLinear(scip, cons, lhs) - @SC SCIPchgRhsLinear(scip, cons, rhs) + @SC SCIPchgLhsLinear(scip(o), cons(o, ci), lhs) + @SC SCIPchgRhsLinear(scip(o), cons(o, ci), rhs) return nothing end @@ -251,16 +246,16 @@ function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SVF, S}) where S end function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SVF, S}) where S <: BOUNDS - var = get_var(o.mscip, ci.value) - lb, ub = SCIPvarGetLbOriginal(var), SCIPvarGetUbOriginal(var) + v = var(o.mscip, ci.value) + lb, ub = SCIPvarGetLbOriginal(v), SCIPvarGetUbOriginal(v) from_bounds(S, lb, ub) end function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S <: BOUNDS - scip, cons = get_scip(o), get_cons(o, ci) - nvars::Int = SCIPgetNVarsLinear(scip, cons) - vars = unsafe_wrap(Array{Ptr{SCIP_VAR}}, SCIPgetVarsLinear(scip, cons), nvars) - vals = unsafe_wrap(Array{Float64}, SCIPgetValsLinear(scip, cons), nvars) + s, cons = scip(o), cons(o, ci) + nvars::Int = SCIPgetNVarsLinear(s, cons) + vars = unsafe_wrap(Array{Ptr{SCIP_VAR}}, SCIPgetVarsLinear(s, cons), nvars) + vals = unsafe_wrap(Array{Float64}, SCIPgetValsLinear(s, cons), nvars) terms = [SAT(vals[i], VI(get_index(o, vars[i]))) for i=1:nvars] @@ -269,37 +264,37 @@ function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S end function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SAF, S}) where S <: BOUNDS - scip, cons = get_scip(o), get_cons(o, ci) - lhs, rhs = SCIPgetLhsLinear(scip, cons), SCIPgetRhsLinear(scip, cons) + lhs = SCIPgetLhsLinear(scip(o), cons(o, ci)) + rhs = SCIPgetRhsLinear(scip(o), cons(o, ci)) from_bounds(S, lhs, rhs) end function MOI.get(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:BOUNDS}) - SCIPconsGetName(get_cons(o, ci)) + SCIPconsGetName(cons(o, ci)) end function MOI.set(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:BOUNDS}, name::String) - @SC SCIPchgConsName(get_scip(o), get_cons(o, ci), name) + @SC SCIPchgConsName(scip(o), cons(o, ci), name) end function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, obj::SAF) allow_modification(o) - scip = get_scip(o) + s = scip(o) # reset objective coefficient of all variables first for v in o.mscip.vars - @SC SCIPchgVarObj(scip, v[], 0.0) + @SC SCIPchgVarObj(s, v[], 0.0) end # set new objective coefficients, summing coefficients for t in obj.terms - var = get_var(o, t.variable_index) - oldcoef = SCIPvarGetObj(var) + v = var(o, t.variable_index) + oldcoef = SCIPvarGetObj(v) newcoef = oldcoef + t.coefficient - @SC SCIPchgVarObj(scip, var, newcoef) + @SC SCIPchgVarObj(s, v, newcoef) end - @SC SCIPaddOrigObjoffset(scip, obj.constant - SCIPgetOrigObjoffset(scip)) + @SC SCIPaddOrigObjoffset(s, obj.constant - SCIPgetOrigObjoffset(s)) return nothing end @@ -308,39 +303,39 @@ function MOI.get(o::Optimizer, ::MOI.ObjectiveFunction{SAF}) terms = SAT[] for i = 1:length(o.mscip.vars) vi = VI(i) - coef = SCIPvarGetObj(get_var(o, vi)) + coef = SCIPvarGetObj(var(o, vi)) coef == 0.0 || push!(terms, SAT(coef, vi)) end - constant = SCIPgetOrigObjoffset(get_scip(o)) + constant = SCIPgetOrigObjoffset(scip(o)) return SAF(terms, constant) end function MOI.set(o::Optimizer, ::MOI.ObjectiveSense, sense::MOI.OptimizationSense) allow_modification(o) if sense == MOI.MIN_SENSE - @SC SCIPsetObjsense(get_scip(o), SCIP_OBJSENSE_MINIMIZE) + @SC SCIPsetObjsense(scip(o), SCIP_OBJSENSE_MINIMIZE) elseif sense == MOI.MAX_SENSE - @SC SCIPsetObjsense(get_scip(o), SCIP_OBJSENSE_MAXIMIZE) + @SC SCIPsetObjsense(scip(o), SCIP_OBJSENSE_MAXIMIZE) end return nothing end function MOI.get(o::Optimizer, ::MOI.ObjectiveSense) - SCIPgetObjsense(get_scip(o)) == SCIP_OBJSENSE_MAXIMIZE ? + SCIPgetObjsense(scip(o)) == SCIP_OBJSENSE_MAXIMIZE ? MOI.MAX_SENSE : MOI.MIN_SENSE end function MOI.modify(o::Optimizer, ci::CI{SAF, <:BOUNDS}, change::SCC) allow_modification(o) - @SC SCIPchgCoefLinear(get_scip(o), get_cons(o, ci), - get_var(o, change.variable), change.new_coefficient) + @SC SCIPchgCoefLinear(scip(o), cons(o, ci), + var(o, change.variable), change.new_coefficient) return nothing end function MOI.modify(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, change::SCC) allow_modification(o) - @SC SCIPchgVarObj(get_scip(o), get_var(o, change.variable), + @SC SCIPchgVarObj(scip(o), var(o, change.variable), change.new_coefficient) return nothing end @@ -348,7 +343,7 @@ end ## optimization and results function MOI.optimize!(o::Optimizer) - @SC SCIPsolve(get_scip(o)) + @SC SCIPsolve(scip(o)) return nothing end @@ -372,43 +367,39 @@ term_status_map = Dict( ) function MOI.get(o::Optimizer, ::MOI.TerminationStatus) - term_status_map[SCIPgetStatus(get_scip(o))] + term_status_map[SCIPgetStatus(scip(o))] end function MOI.get(o::Optimizer, ::MOI.PrimalStatus) - SCIPgetNSols(get_scip(o)) > 0 ? MOI.FEASIBLE_POINT : MOI.NO_SOLUTION + SCIPgetNSols(scip(o)) > 0 ? MOI.FEASIBLE_POINT : MOI.NO_SOLUTION end function MOI.get(o::Optimizer, ::MOI.ResultCount) - status = SCIPgetStatus(get_scip(o)) + status = SCIPgetStatus(scip(o)) if status in [SCIP_STATUS_UNBOUNDED, SCIP_STATUS_INFORUNBD] return 0 end - return SCIPgetNSols(get_scip(o)) + return SCIPgetNSols(scip(o)) end function MOI.get(o::Optimizer, ::MOI.ObjectiveValue) - scip = get_scip(o) - return SCIPgetSolOrigObj(scip, SCIPgetBestSol(scip)) + return SCIPgetSolOrigObj(scip(o), SCIPgetBestSol(scip(o))) end function MOI.get(o::Optimizer, ::MOI.VariablePrimal, vi::VI) - scip = get_scip(o) - return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, vi)) + return SCIPgetSolVal(scip(o), SCIPgetBestSol(scip(o)), var(o, vi)) end function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SVF,<:BOUNDS}) - scip = get_scip(o) - return SCIPgetSolVal(scip, SCIPgetBestSol(scip), get_var(o, VI(ci.value))) + return SCIPgetSolVal(scip(o), SCIPgetBestSol(scip(o)), var(o, VI(ci.value))) end function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SAF,<:BOUNDS}) - scip = get_scip(o) - return SCIPgetActivityLinear(scip, get_cons(o, ci), SCIPgetBestSol(scip)) + return SCIPgetActivityLinear(scip(o), cons(o, ci), SCIPgetBestSol(scip(o))) end -MOI.get(o::Optimizer, ::MOI.ObjectiveBound) = SCIPgetDualbound(get_scip(o)) -MOI.get(o::Optimizer, ::MOI.RelativeGap) = SCIPgetGap(get_scip(o)) -MOI.get(o::Optimizer, ::MOI.SolveTime) = SCIPgetSolvingTime(get_scip(o)) -MOI.get(o::Optimizer, ::MOI.SimplexIterations) = SCIPgetNLPIterations(get_scip(o)) -MOI.get(o::Optimizer, ::MOI.NodeCount) = SCIPgetNNodes(get_scip(o)) +MOI.get(o::Optimizer, ::MOI.ObjectiveBound) = SCIPgetDualbound(scip(o)) +MOI.get(o::Optimizer, ::MOI.RelativeGap) = SCIPgetGap(scip(o)) +MOI.get(o::Optimizer, ::MOI.SolveTime) = SCIPgetSolvingTime(scip(o)) +MOI.get(o::Optimizer, ::MOI.SimplexIterations) = SCIPgetNLPIterations(scip(o)) +MOI.get(o::Optimizer, ::MOI.NodeCount) = SCIPgetNNodes(scip(o)) diff --git a/src/managed_scip.jl b/src/managed_scip.jl index 5a0abf93..8ba85ba0 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -19,38 +19,37 @@ end "Release references and free memory." function free_scip(mscip::ManagedSCIP) # Avoid double-free (SCIP will set the pointers to NULL). - scip = get_scip(mscip) - if scip != C_NULL - for cons in mscip.conss - @SC SCIPreleaseCons(scip, cons) + s = scip(mscip) + if s != C_NULL + for c in mscip.conss + @SC SCIPreleaseCons(s, c) end - for var in mscip.vars - @SC SCIPreleaseVar(scip, var) + for v in mscip.vars + @SC SCIPreleaseVar(s, v) end @SC SCIPfree(mscip.scip) end - @assert get_scip(mscip) == C_NULL + @assert scip(mscip) == C_NULL end "Return pointer to SCIP instance." -get_scip(mscip::ManagedSCIP) = mscip.scip[] +scip(mscip::ManagedSCIP) = mscip.scip[] "Return pointer to SCIP variable." -get_var(mscip::ManagedSCIP, i::Int) = mscip.vars[i][] +var(mscip::ManagedSCIP, i::Int) = mscip.vars[i][] "Return pointer to SCIP constraint." -get_cons(mscip::ManagedSCIP, i::Int) = mscip.conss[i][] +cons(mscip::ManagedSCIP, i::Int) = mscip.conss[i][] "Add variable to problem (continuous, no bounds), return variable index." function add_variable(mscip::ManagedSCIP) - scip = get_scip(mscip) - var = Ref{Ptr{SCIP_VAR}}() - @SC rc = SCIPcreateVarBasic( - scip, var, "", -SCIPinfinity(scip), - SCIPinfinity(scip), 0.0, SCIP_VARTYPE_CONTINUOUS) - @SC rc = SCIPaddVar(scip, var[]) + s = scip(mscip) + var__ = Ref{Ptr{SCIP_VAR}}() + @SC rc = SCIPcreateVarBasic(s, var__, "", -SCIPinfinity(s), SCIPinfinity(s), + 0.0, SCIP_VARTYPE_CONTINUOUS) + @SC rc = SCIPaddVar(s, var__[]) - push!(mscip.vars, var) + push!(mscip.vars, var__) # can't delete variable, so we use the array position as index return length(mscip.vars) end @@ -68,12 +67,11 @@ Use `(-)SCIPinfinity(scip)` for one of the bounds if not applicable. """ function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) @assert length(varidx) == length(coeffs) - scip = get_scip(mscip) - vars = [get_var(mscip, i) for i in varidx] + vars = [var(mscip, i) for i in varidx] cons = Ref{Ptr{SCIP_CONS}}() @SC rc = SCIPcreateConsBasicLinear( - scip, cons, "", length(vars), vars, coeffs, lhs, rhs) - @SC rc = SCIPaddCons(scip, cons[]) + scip(mscip), cons, "", length(vars), vars, coeffs, lhs, rhs) + @SC rc = SCIPaddCons(scip(mscip), cons[]) push!(mscip.conss, cons) # can't delete constraint, so we use the array position as index @@ -82,6 +80,6 @@ end "Set generic parameter." function set_parameter(mscip::ManagedSCIP, name::String, value) - @SC SCIPsetParam(get_scip(mscip), name, Ptr{Cvoid}(value)) + @SC SCIPsetParam(scip(mscip), name, Ptr{Cvoid}(value)) return nothing end From 8a89494071e438bf9c1865f8abc0155b0ce54844 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 12:55:19 +0100 Subject: [PATCH 73/82] introduce VarRef, ConsRef in place of Ints --- src/MOI_wrapper.jl | 55 ++++++++++++++++++++++----------------------- src/managed_scip.jl | 40 +++++++++++++++++++++------------ 2 files changed, 53 insertions(+), 42 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 27ca7b86..2f37b386 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -22,12 +22,12 @@ const SCC = MOI.ScalarCoefficientChange{Float64} # other MOI types const SAT = MOI.ScalarAffineTerm{Float64} -const PtrMap = Dict{Ptr{Cvoid}, Int} -const ConsTypeMap = Dict{Tuple{DataType, DataType}, Vector{Int}} +const PtrMap = Dict{Ptr{Cvoid}, REF} +const ConsTypeMap = Dict{Tuple{DataType, DataType}, Vector{ConsRef}} mutable struct Optimizer <: MOI.AbstractOptimizer mscip::ManagedSCIP - index::PtrMap + reference::PtrMap constypes::ConsTypeMap params::Dict{String,Any} @@ -41,13 +41,13 @@ end scip(o::Optimizer) = scip(o.mscip) "Return pointer to SCIP variable." -var(o::Optimizer, v::VI) = var(o.mscip, v.value) +var(o::Optimizer, v::VI) = var(o.mscip, VarRef(v.value)) -"Return index of SCIP variable/constraint." -get_index(o::Optimizer, var::Ptr{Cvoid}) = o.index[var] +"Return var/cons reference of SCIP variable/constraint." +ref(o::Optimizer, ptr::Ptr{Cvoid}) = o.reference[ptr] "Return pointer to SCIP constraint." -cons(o::Optimizer, c::CI{F,S}) where {F,S} = cons(o.mscip, c.value) +cons(o::Optimizer, c::CI{F,S}) where {F,S} = cons(o.mscip, ConsRef(c.value)) "Extract bounds from sets." bounds(set::EQS) = (set.value, set.value) @@ -61,19 +61,20 @@ from_bounds(::Type{GTS}, lower, upper) = GTS(lower) from_bounds(::Type{LTS}, lower, upper) = LTS(upper) from_bounds(::Type{INS}, lower, upper) = INS(lower, upper) -"Register variable in mapping, return variable index." -function register!(o::Optimizer, var::Ptr{SCIP_VAR}, index::Int) - @assert !haskey(o.index, var) - o.index[var] = index - return index +"Register pointer in mapping, return var/cons reference." +function register!(o::Optimizer, ptr::Ptr{Cvoid}, ref::R) where R <: REF + @assert !haskey(o.reference, ptr) + o.reference[ptr] = ref + return ref end -"Register constraint in mapping, return constraint index." +"Register constraint in mapping, return constraint reference." function register!(o::Optimizer, c::CI{F,S}) where {F,S} + cr = ConsRef(c.value) if haskey(o.constypes, (F, S)) - push!(o.constypes[F,S], c.value) + push!(o.constypes[F,S], cr) else - o.constypes[F,S] = [c.value] + o.constypes[F,S] = [cr] end return c end @@ -123,7 +124,7 @@ function MOI.empty!(o::Optimizer) # create a new one o.mscip = ManagedSCIP() # clear auxiliary mapping structures - o.index = PtrMap() + o.reference = PtrMap() o.constypes = ConsTypeMap() # reapply parameters for pair in o.params @@ -141,10 +142,10 @@ MOI.set(o::Optimizer, ::MOI.Name, name::String) = @SC SCIPsetProbName(scip(o), n function MOI.add_variable(o::Optimizer) allow_modification(o) - i::Int = add_variable(o.mscip) - var::Ptr{SCIP_VAR} = o.mscip.vars[i][] # i == end - register!(o, var, i) - return MOI.VariableIndex(i) + vr = add_variable(o.mscip) + var::Ptr{SCIP_VAR} = o.mscip.vars[vr.val][] # i == end + register!(o, var, vr) + return MOI.VariableIndex(vr.val) end MOI.add_variables(o::Optimizer, n) = [MOI.add_variable(o) for i=1:n] @@ -206,17 +207,17 @@ function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: BOUNDS} allow_modification(o) - varidx = [t.variable_index.value for t in func.terms] + varrefs = [VarRef(t.variable_index.value) for t in func.terms] coefs = [t.coefficient for t in func.terms] lhs, rhs = bounds(set) lhs = lhs == nothing ? -SCIPinfinity(scip(o)) : lhs rhs = rhs == nothing ? SCIPinfinity(scip(o)) : rhs - i = add_linear_constraint(o.mscip, varidx, coefs, lhs, rhs) - ci = CI{SAF, S}(i) + cr = add_linear_constraint(o.mscip, varrefs, coefs, lhs, rhs) + ci = CI{SAF, S}(cr.val) register!(o, ci) - register!(o, cons(o, ci), i) + register!(o, cons(o, ci), cr) return ci end @@ -257,8 +258,7 @@ function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S vars = unsafe_wrap(Array{Ptr{SCIP_VAR}}, SCIPgetVarsLinear(s, cons), nvars) vals = unsafe_wrap(Array{Float64}, SCIPgetValsLinear(s, cons), nvars) - terms = [SAT(vals[i], VI(get_index(o, vars[i]))) - for i=1:nvars] + terms = [SAT(vals[i], VI(ref(o, vars[i]).val)) for i=1:nvars] # can not identify constant anymore (is merged with lhs,rhs) return SAF(terms, 0.0) end @@ -335,8 +335,7 @@ end function MOI.modify(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, change::SCC) allow_modification(o) - @SC SCIPchgVarObj(scip(o), var(o, change.variable), - change.new_coefficient) + @SC SCIPchgVarObj(scip(o), var(o, change.variable), change.new_coefficient) return nothing end diff --git a/src/managed_scip.jl b/src/managed_scip.jl index 8ba85ba0..ccc69ae8 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -32,16 +32,28 @@ function free_scip(mscip::ManagedSCIP) @assert scip(mscip) == C_NULL end +"Type-safe wrapper for `Int64`, references a variable." +struct VarRef + val::Int64 +end + +"Type-safe wrapper for `Int64`, references a constraint." +struct ConsRef + val::Int64 +end + +const REF = Union{VarRef,ConsRef} + "Return pointer to SCIP instance." scip(mscip::ManagedSCIP) = mscip.scip[] "Return pointer to SCIP variable." -var(mscip::ManagedSCIP, i::Int) = mscip.vars[i][] +var(mscip::ManagedSCIP, vr::VarRef) = mscip.vars[vr.val][] "Return pointer to SCIP constraint." -cons(mscip::ManagedSCIP, i::Int) = mscip.conss[i][] +cons(mscip::ManagedSCIP, cr::ConsRef) = mscip.conss[cr.val][] -"Add variable to problem (continuous, no bounds), return variable index." +"Add variable to problem (continuous, no bounds), return var ref." function add_variable(mscip::ManagedSCIP) s = scip(mscip) var__ = Ref{Ptr{SCIP_VAR}}() @@ -51,31 +63,31 @@ function add_variable(mscip::ManagedSCIP) push!(mscip.vars, var__) # can't delete variable, so we use the array position as index - return length(mscip.vars) + return VarRef(length(mscip.vars)) end """ -Add (ranged) linear constraint to problem, return constraint index. +Add (ranged) linear constraint to problem, return cons ref. # Arguments -- `varidx::AbstractArray{Int}`: indices of variables for affine terms. +- `varrefs::AbstractArray{VarRef}`: variable references for affine terms. - `coeffs::AbstractArray{Float64}`: coefficients for affine terms. - `lhs::Float64`: left-hand side for ranged constraint - `rhs::Float64`: right-hand side for ranged constraint Use `(-)SCIPinfinity(scip)` for one of the bounds if not applicable. """ -function add_linear_constraint(mscip::ManagedSCIP, varidx, coeffs, lhs, rhs) - @assert length(varidx) == length(coeffs) - vars = [var(mscip, i) for i in varidx] - cons = Ref{Ptr{SCIP_CONS}}() +function add_linear_constraint(mscip::ManagedSCIP, varrefs, coeffs, lhs, rhs) + @assert length(varrefs) == length(coeffs) + vars = [var(mscip, vr) for vr in varrefs] + cons__ = Ref{Ptr{SCIP_CONS}}() @SC rc = SCIPcreateConsBasicLinear( - scip(mscip), cons, "", length(vars), vars, coeffs, lhs, rhs) - @SC rc = SCIPaddCons(scip(mscip), cons[]) + scip(mscip), cons__, "", length(vars), vars, coeffs, lhs, rhs) + @SC rc = SCIPaddCons(scip(mscip), cons__[]) - push!(mscip.conss, cons) + push!(mscip.conss, cons__) # can't delete constraint, so we use the array position as index - return length(mscip.conss) + return ConsRef(length(mscip.conss)) end "Set generic parameter." From d231570c52c152591f575fcb380998d7747eef22 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 14:12:32 +0100 Subject: [PATCH 74/82] add copyright notice to files from Clang.jl --- src/wrapper/CEnum.jl | 2 ++ src/wrapper/ctypes.jl | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/wrapper/CEnum.jl b/src/wrapper/CEnum.jl index 8f5fe61d..29eb16ee 100644 --- a/src/wrapper/CEnum.jl +++ b/src/wrapper/CEnum.jl @@ -1,3 +1,5 @@ +# Copyright (c) 2018 Isaiah Norton and other [contributors](https://github.com/ihnorton/Clang.jl/graphs/contributors) + module CEnum abstract type Cenum{T} end diff --git a/src/wrapper/ctypes.jl b/src/wrapper/ctypes.jl index 436e6ad0..6c11d67b 100644 --- a/src/wrapper/ctypes.jl +++ b/src/wrapper/ctypes.jl @@ -1,3 +1,5 @@ +# Copyright (c) 2018 Isaiah Norton and other [contributors](https://github.com/ihnorton/Clang.jl/graphs/contributors) +# ## TODO: pending https://github.com/JuliaLang/julia/issues/29420 # this one is suggested in the issue, but it looks like time_t and tm are two different things? # const Ctime_t = Base.Libc.TmStruct From d8a5fd8e96fa48e794aa16b7d1f72151a4772b2a Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 14:39:58 +0100 Subject: [PATCH 75/82] reconsider type aliases - remove those that are used infrequently - use longer, more descriptive names - use CamelCase when abbreviated name is more than just initials --- src/MOI_wrapper.jl | 89 +++++++++++++++++++++------------------------ src/managed_scip.jl | 2 - 2 files changed, 42 insertions(+), 49 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 2f37b386..11089bd8 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -9,20 +9,13 @@ const CI = MOI.ConstraintIndex const SVF = MOI.SingleVariable const SAF = MOI.ScalarAffineFunction{Float64} # supported sets -const EQS = MOI.EqualTo{Float64} -const GTS = MOI.GreaterThan{Float64} -const LTS = MOI.LessThan{Float64} -const INS = MOI.Interval{Float64} -const BOUNDS = Union{EQS, GTS, LTS, INS} -const BINS = MOI.ZeroOne -const INTS = MOI.Integer -const TYPES = Union{BINS, INTS} -# support changes -const SCC = MOI.ScalarCoefficientChange{Float64} +const Bounds = Union{MOI.EqualTo{Float64}, MOI.GreaterThan{Float64}, + MOI.LessThan{Float64}, MOI.Interval{Float64}} +const VarTypes = Union{MOI.ZeroOne, MOI.Integer} # other MOI types -const SAT = MOI.ScalarAffineTerm{Float64} +const AffTerm = MOI.ScalarAffineTerm{Float64} -const PtrMap = Dict{Ptr{Cvoid}, REF} +const PtrMap = Dict{Ptr{Cvoid}, Union{VarRef, ConsRef}} const ConsTypeMap = Dict{Tuple{DataType, DataType}, Vector{ConsRef}} mutable struct Optimizer <: MOI.AbstractOptimizer @@ -50,19 +43,19 @@ ref(o::Optimizer, ptr::Ptr{Cvoid}) = o.reference[ptr] cons(o::Optimizer, c::CI{F,S}) where {F,S} = cons(o.mscip, ConsRef(c.value)) "Extract bounds from sets." -bounds(set::EQS) = (set.value, set.value) -bounds(set::GTS) = (set.lower, nothing) -bounds(set::LTS) = (nothing, set.upper) -bounds(set::INS) = (set.lower, set.upper) +bounds(set::MOI.EqualTo{Float64}) = (set.value, set.value) +bounds(set::MOI.GreaterThan{Float64}) = (set.lower, nothing) +bounds(set::MOI.LessThan{Float64}) = (nothing, set.upper) +bounds(set::MOI.Interval{Float64}) = (set.lower, set.upper) "Make set from bounds." -from_bounds(::Type{EQS}, lower, upper) = EQS(lower) # should == upper -from_bounds(::Type{GTS}, lower, upper) = GTS(lower) -from_bounds(::Type{LTS}, lower, upper) = LTS(upper) -from_bounds(::Type{INS}, lower, upper) = INS(lower, upper) +from_bounds(::Type{MOI.EqualTo{Float64}}, lower, upper) = MOI.EqualTo{Float64}(lower) +from_bounds(::Type{MOI.GreaterThan{Float64}}, lower, upper) = MOI.GreaterThan{Float64}(lower) +from_bounds(::Type{MOI.LessThan{Float64}}, lower, upper) = MOI.LessThan{Float64}(upper) +from_bounds(::Type{MOI.Interval{Float64}}, lower, upper) = MOI.Interval{Float64}(lower, upper) "Register pointer in mapping, return var/cons reference." -function register!(o::Optimizer, ptr::Ptr{Cvoid}, ref::R) where R <: REF +function register!(o::Optimizer, ptr::Ptr{Cvoid}, ref::R) where R <: Union{VarRef, ConsRef} @assert !haskey(o.reference, ptr) o.reference[ptr] = ref return ref @@ -92,11 +85,11 @@ end MOI.get(::Optimizer, ::MOI.SolverName) = "SCIP" # variable bounds -MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:BOUNDS}) = true +MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:Bounds}) = true # variable types (binary, integer) -MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:TYPES}) = true +MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:VarTypes}) = true # linear constraints -MOI.supports_constraint(o::Optimizer, ::Type{SAF}, ::Type{<:BOUNDS}) = true +MOI.supports_constraint(o::Optimizer, ::Type{SAF}, ::Type{<:Bounds}) = true MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{SAF}) = true @@ -158,14 +151,14 @@ function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) @SC SCIPchgVarName(scip(o), var(o, vi), name) end -scip_vartype(::Type{BINS}) = SCIP_VARTYPE_BINARY -scip_vartype(::Type{INTS}) = SCIP_VARTYPE_INTEGER -function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where {S <: TYPES} +scip_vartype(::Type{MOI.ZeroOne}) = SCIP_VARTYPE_BINARY +scip_vartype(::Type{MOI.Integer}) = SCIP_VARTYPE_INTEGER +function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where {S <: VarTypes} allow_modification(o) v = var(o, func.variable) infeasible = Ref{Ptr{SCIP_Bool}} @SC SCIPchgVarType(scip(o), v, scip_vartype(S), infeasible[]) - if S <: BINS + if S <: MOI.ZeroOne # need to adjust bounds for SCIP?! @SC SCIPchgVarLb(scip(o), v, 0.0) @SC SCIPchgVarUb(scip(o), v, 1.0) @@ -175,7 +168,7 @@ function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where {S <: TYPES} return register!(o, CI{SVF, S}(i)) end -function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: BOUNDS +function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: Bounds allow_modification(o) v = var(o, func.variable) lb, ub = bounds(set) @@ -186,7 +179,7 @@ function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: BOUNDS return register!(o, CI{SVF, S}(i)) end -function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) where {S <: BOUNDS} +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) where {S <: Bounds} allow_modification(o) v = var(o, VI(ci.value)) # cons index is actually var index lb, ub = bounds(set) @@ -195,11 +188,11 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) return nothing end -function MOI.is_valid(o::Optimizer, ci::CI{SVF,<:BOUNDS}) +function MOI.is_valid(o::Optimizer, ci::CI{SVF,<:Bounds}) 1 <= ci.value <= length(o.mscip.vars) end -function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: BOUNDS} +function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: Bounds} if func.constant != 0.0 msg = "SCIP does not support linear constraints with a constant offset." throw(MOI.AddConstraintNotAllowed{SAF, S}(msg)) @@ -221,7 +214,7 @@ function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: BOUNDS} return ci end -function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) where {S <: BOUNDS} +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) where {S <: Bounds} allow_modification(o) lhs, rhs = bounds(set) @@ -234,7 +227,7 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) return nothing end -function MOI.is_valid(o::Optimizer, ci::CI{SAF,<:BOUNDS}) +function MOI.is_valid(o::Optimizer, ci::CI{SAF,<:Bounds}) 1 <= ci.value <= length(o.mscip.cons) end @@ -242,38 +235,38 @@ function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} haskey(o.constypes, (F, S)) ? length(o.constypes[F, S]) : 0 end -function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SVF, S}) where S <: BOUNDS +function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SVF, S}) where S <: Bounds SVF(ci) end -function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SVF, S}) where S <: BOUNDS +function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SVF, S}) where S <: Bounds v = var(o.mscip, ci.value) lb, ub = SCIPvarGetLbOriginal(v), SCIPvarGetUbOriginal(v) from_bounds(S, lb, ub) end -function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S <: BOUNDS +function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S <: Bounds s, cons = scip(o), cons(o, ci) nvars::Int = SCIPgetNVarsLinear(s, cons) vars = unsafe_wrap(Array{Ptr{SCIP_VAR}}, SCIPgetVarsLinear(s, cons), nvars) vals = unsafe_wrap(Array{Float64}, SCIPgetValsLinear(s, cons), nvars) - terms = [SAT(vals[i], VI(ref(o, vars[i]).val)) for i=1:nvars] + terms = [AffTerm(vals[i], VI(ref(o, vars[i]).val)) for i=1:nvars] # can not identify constant anymore (is merged with lhs,rhs) return SAF(terms, 0.0) end -function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SAF, S}) where S <: BOUNDS +function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SAF, S}) where S <: Bounds lhs = SCIPgetLhsLinear(scip(o), cons(o, ci)) rhs = SCIPgetRhsLinear(scip(o), cons(o, ci)) from_bounds(S, lhs, rhs) end -function MOI.get(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:BOUNDS}) +function MOI.get(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:Bounds}) SCIPconsGetName(cons(o, ci)) end -function MOI.set(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:BOUNDS}, name::String) +function MOI.set(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:Bounds}, name::String) @SC SCIPchgConsName(scip(o), cons(o, ci), name) end @@ -300,11 +293,11 @@ function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, obj::SAF) end function MOI.get(o::Optimizer, ::MOI.ObjectiveFunction{SAF}) - terms = SAT[] + terms = AffTerm[] for i = 1:length(o.mscip.vars) vi = VI(i) coef = SCIPvarGetObj(var(o, vi)) - coef == 0.0 || push!(terms, SAT(coef, vi)) + coef == 0.0 || push!(terms, AffTerm(coef, vi)) end constant = SCIPgetOrigObjoffset(scip(o)) return SAF(terms, constant) @@ -326,14 +319,16 @@ function MOI.get(o::Optimizer, ::MOI.ObjectiveSense) MOI.MIN_SENSE end -function MOI.modify(o::Optimizer, ci::CI{SAF, <:BOUNDS}, change::SCC) +function MOI.modify(o::Optimizer, ci::CI{SAF, <:Bounds}, + change::MOI.ScalarCoefficientChange{Float64}) allow_modification(o) @SC SCIPchgCoefLinear(scip(o), cons(o, ci), var(o, change.variable), change.new_coefficient) return nothing end -function MOI.modify(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, change::SCC) +function MOI.modify(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, + change::MOI.ScalarCoefficientChange{Float64}) allow_modification(o) @SC SCIPchgVarObj(scip(o), var(o, change.variable), change.new_coefficient) return nothing @@ -389,11 +384,11 @@ function MOI.get(o::Optimizer, ::MOI.VariablePrimal, vi::VI) return SCIPgetSolVal(scip(o), SCIPgetBestSol(scip(o)), var(o, vi)) end -function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SVF,<:BOUNDS}) +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SVF,<:Bounds}) return SCIPgetSolVal(scip(o), SCIPgetBestSol(scip(o)), var(o, VI(ci.value))) end -function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SAF,<:BOUNDS}) +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SAF,<:Bounds}) return SCIPgetActivityLinear(scip(o), cons(o, ci), SCIPgetBestSol(scip(o))) end diff --git a/src/managed_scip.jl b/src/managed_scip.jl index ccc69ae8..dcaf5f92 100644 --- a/src/managed_scip.jl +++ b/src/managed_scip.jl @@ -42,8 +42,6 @@ struct ConsRef val::Int64 end -const REF = Union{VarRef,ConsRef} - "Return pointer to SCIP instance." scip(mscip::ManagedSCIP) = mscip.scip[] From 8d70941617c1d721031fbe93fca121699c9db59c Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 14:48:27 +0100 Subject: [PATCH 76/82] add explicit return keywords to functions --- src/MOI_wrapper.jl | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 11089bd8..edc258b8 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -108,7 +108,7 @@ end ## model creation, query and modification function MOI.is_empty(o::Optimizer) - length(o.mscip.vars) == 0 && length(o.mscip.conss) == 0 + return length(o.mscip.vars) == 0 && length(o.mscip.conss) == 0 end function MOI.empty!(o::Optimizer) @@ -127,7 +127,7 @@ function MOI.empty!(o::Optimizer) end function MOI.copy_to(dest::Optimizer, src::MOI.ModelLike; kws...) - MOIU.automatic_copy_to(dest, src; kws...) + return MOIU.automatic_copy_to(dest, src; kws...) end MOI.get(o::Optimizer, ::MOI.Name) = SCIPgetProbName(scip(o)) @@ -149,6 +149,7 @@ MOI.is_valid(o::Optimizer, vi::VI) = 1 <= vi.value <= length(o.mscip.vars) MOI.get(o::Optimizer, ::MOI.VariableName, vi::VI) = SCIPvarGetName(var(o, vi)) function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String) @SC SCIPchgVarName(scip(o), var(o, vi), name) + return nothing end scip_vartype(::Type{MOI.ZeroOne}) = SCIP_VARTYPE_BINARY @@ -189,7 +190,7 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) end function MOI.is_valid(o::Optimizer, ci::CI{SVF,<:Bounds}) - 1 <= ci.value <= length(o.mscip.vars) + return 1 <= ci.value <= length(o.mscip.vars) end function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: Bounds} @@ -228,21 +229,21 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) end function MOI.is_valid(o::Optimizer, ci::CI{SAF,<:Bounds}) - 1 <= ci.value <= length(o.mscip.cons) + return 1 <= ci.value <= length(o.mscip.cons) end function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} - haskey(o.constypes, (F, S)) ? length(o.constypes[F, S]) : 0 + return haskey(o.constypes, (F, S)) ? length(o.constypes[F, S]) : 0 end function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SVF, S}) where S <: Bounds - SVF(ci) + return SVF(ci) end function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SVF, S}) where S <: Bounds v = var(o.mscip, ci.value) lb, ub = SCIPvarGetLbOriginal(v), SCIPvarGetUbOriginal(v) - from_bounds(S, lb, ub) + return from_bounds(S, lb, ub) end function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S <: Bounds @@ -259,15 +260,16 @@ end function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SAF, S}) where S <: Bounds lhs = SCIPgetLhsLinear(scip(o), cons(o, ci)) rhs = SCIPgetRhsLinear(scip(o), cons(o, ci)) - from_bounds(S, lhs, rhs) + return from_bounds(S, lhs, rhs) end function MOI.get(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:Bounds}) - SCIPconsGetName(cons(o, ci)) + return SCIPconsGetName(cons(o, ci)) end function MOI.set(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:Bounds}, name::String) @SC SCIPchgConsName(scip(o), cons(o, ci), name) + return nothing end function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, obj::SAF) @@ -314,9 +316,7 @@ function MOI.set(o::Optimizer, ::MOI.ObjectiveSense, sense::MOI.OptimizationSens end function MOI.get(o::Optimizer, ::MOI.ObjectiveSense) - SCIPgetObjsense(scip(o)) == SCIP_OBJSENSE_MAXIMIZE ? - MOI.MAX_SENSE : - MOI.MIN_SENSE + return SCIPgetObjsense(scip(o)) == SCIP_OBJSENSE_MAXIMIZE ? MOI.MAX_SENSE : MOI.MIN_SENSE end function MOI.modify(o::Optimizer, ci::CI{SAF, <:Bounds}, @@ -361,11 +361,11 @@ term_status_map = Dict( ) function MOI.get(o::Optimizer, ::MOI.TerminationStatus) - term_status_map[SCIPgetStatus(scip(o))] + return term_status_map[SCIPgetStatus(scip(o))] end function MOI.get(o::Optimizer, ::MOI.PrimalStatus) - SCIPgetNSols(scip(o)) > 0 ? MOI.FEASIBLE_POINT : MOI.NO_SOLUTION + return SCIPgetNSols(scip(o)) > 0 ? MOI.FEASIBLE_POINT : MOI.NO_SOLUTION end function MOI.get(o::Optimizer, ::MOI.ResultCount) From 3ea173ac98d27a26c5a0896dfc2010cad5c9ed49 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 14:49:12 +0100 Subject: [PATCH 77/82] rm empty test/REQUIRE --- test/REQUIRE | 1 - 1 file changed, 1 deletion(-) delete mode 100644 test/REQUIRE diff --git a/test/REQUIRE b/test/REQUIRE deleted file mode 100644 index 8b137891..00000000 --- a/test/REQUIRE +++ /dev/null @@ -1 +0,0 @@ - From 04e31fe03ae776a70991d0db7c675b8f9a9d777d Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 14:50:05 +0100 Subject: [PATCH 78/82] rm test that depends on GC behavior --- test/managed_scip.jl | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/test/managed_scip.jl b/test/managed_scip.jl index f5c668b2..7d932ea3 100644 --- a/test/managed_scip.jl +++ b/test/managed_scip.jl @@ -14,18 +14,6 @@ end @test mscip.scip[] == C_NULL end -@testset "create and implicit free" begin - ptr = Ref{Ptr{SCIP.SCIP_}}(C_NULL) - for i = 1:1 - mscip = SCIP.ManagedSCIP() - ptr = mscip.scip - @test ptr[] != C_NULL - end - GC.gc() - GC.gc() # TODO: why need a second call? - @test ptr[] == C_NULL -end - @testset "create with vars and cons, (no solve), and free" begin mscip = SCIP.ManagedSCIP() @test mscip.scip[] != C_NULL From f4b5883b87831409ad8bea49c31e0ecd767eb39b Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 15:08:26 +0100 Subject: [PATCH 79/82] add test for memory mgmt with solving --- test/managed_scip.jl | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/test/managed_scip.jl b/test/managed_scip.jl index 7d932ea3..3dbbc378 100644 --- a/test/managed_scip.jl +++ b/test/managed_scip.jl @@ -31,3 +31,26 @@ end end @test mscip.scip[] == C_NULL end + +@testset "create with vars and cons, (no solve), and free" begin + mscip = SCIP.ManagedSCIP() + @test mscip.scip[] != C_NULL + + SCIP.set_parameter(mscip, "display/verblevel", 0) + + x = SCIP.add_variable(mscip) + y = SCIP.add_variable(mscip) + c = SCIP.add_linear_constraint(mscip, [x, y], [2.0, 3.0], 1.0, 9.0) + + # solve, but don't check results (this test is about memory mgmt) + SCIP.@SC SCIP.SCIPsolve(mscip.scip[]) + + finalize(mscip) + for var in mscip.vars + @test var[] == C_NULL + end + for cons in mscip.conss + @test cons[] == C_NULL + end + @test mscip.scip[] == C_NULL +end From 7da7c146a9374d074828bff0cd74429fb7796659 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 21:31:58 +0100 Subject: [PATCH 80/82] warn about setting FEASIBLITY_SENSE --- src/MOI_wrapper.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index edc258b8..3cd99f7b 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -311,6 +311,8 @@ function MOI.set(o::Optimizer, ::MOI.ObjectiveSense, sense::MOI.OptimizationSens @SC SCIPsetObjsense(scip(o), SCIP_OBJSENSE_MINIMIZE) elseif sense == MOI.MAX_SENSE @SC SCIPsetObjsense(scip(o), SCIP_OBJSENSE_MAXIMIZE) + elseif sense == MOI.FEASIBLITY_SENSE + @warn "FEASIBLITY_SENSE not supported by SCIP.jl" maxlog=1 end return nothing end From 3ed02b0fef7b8427809332171c80da520ccada53 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 21:32:08 +0100 Subject: [PATCH 81/82] map gap limit to MOI.OPTIMAL (conform with other solvers) --- src/MOI_wrapper.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index 3cd99f7b..ed70debe 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -351,7 +351,7 @@ term_status_map = Dict( SCIP_STATUS_STALLNODELIMIT => MOI.OTHER_LIMIT, SCIP_STATUS_TIMELIMIT => MOI.TIME_LIMIT, SCIP_STATUS_MEMLIMIT => MOI.MEMORY_LIMIT, - SCIP_STATUS_GAPLIMIT => MOI.OTHER_LIMIT, + SCIP_STATUS_GAPLIMIT => MOI.OPTIMAL, SCIP_STATUS_SOLLIMIT => MOI.SOLUTION_LIMIT, SCIP_STATUS_BESTSOLLIMIT => MOI.OTHER_LIMIT, SCIP_STATUS_RESTARTLIMIT => MOI.OTHER_LIMIT, From 3b4f08795e47704efe54436deda24f3c340d73a7 Mon Sep 17 00:00:00 2001 From: Robert Schwarz Date: Sun, 6 Jan 2019 21:36:00 +0100 Subject: [PATCH 82/82] constant names consistent with style guide --- src/MOI_wrapper.jl | 50 +++++++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl index ed70debe..3169d3cb 100644 --- a/src/MOI_wrapper.jl +++ b/src/MOI_wrapper.jl @@ -9,11 +9,11 @@ const CI = MOI.ConstraintIndex const SVF = MOI.SingleVariable const SAF = MOI.ScalarAffineFunction{Float64} # supported sets -const Bounds = Union{MOI.EqualTo{Float64}, MOI.GreaterThan{Float64}, +const BOUNDS = Union{MOI.EqualTo{Float64}, MOI.GreaterThan{Float64}, MOI.LessThan{Float64}, MOI.Interval{Float64}} -const VarTypes = Union{MOI.ZeroOne, MOI.Integer} +const VAR_TYPES = Union{MOI.ZeroOne, MOI.Integer} # other MOI types -const AffTerm = MOI.ScalarAffineTerm{Float64} +const AFF_TERM = MOI.ScalarAffineTerm{Float64} const PtrMap = Dict{Ptr{Cvoid}, Union{VarRef, ConsRef}} const ConsTypeMap = Dict{Tuple{DataType, DataType}, Vector{ConsRef}} @@ -85,11 +85,11 @@ end MOI.get(::Optimizer, ::MOI.SolverName) = "SCIP" # variable bounds -MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:Bounds}) = true +MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:BOUNDS}) = true # variable types (binary, integer) -MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:VarTypes}) = true +MOI.supports_constraint(o::Optimizer, ::Type{SVF}, ::Type{<:VAR_TYPES}) = true # linear constraints -MOI.supports_constraint(o::Optimizer, ::Type{SAF}, ::Type{<:Bounds}) = true +MOI.supports_constraint(o::Optimizer, ::Type{SAF}, ::Type{<:BOUNDS}) = true MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{SAF}) = true @@ -154,7 +154,7 @@ end scip_vartype(::Type{MOI.ZeroOne}) = SCIP_VARTYPE_BINARY scip_vartype(::Type{MOI.Integer}) = SCIP_VARTYPE_INTEGER -function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where {S <: VarTypes} +function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where {S <: VAR_TYPES} allow_modification(o) v = var(o, func.variable) infeasible = Ref{Ptr{SCIP_Bool}} @@ -169,7 +169,7 @@ function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where {S <: VarType return register!(o, CI{SVF, S}(i)) end -function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: Bounds +function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: BOUNDS allow_modification(o) v = var(o, func.variable) lb, ub = bounds(set) @@ -180,7 +180,7 @@ function MOI.add_constraint(o::Optimizer, func::SVF, set::S) where S <: Bounds return register!(o, CI{SVF, S}(i)) end -function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) where {S <: Bounds} +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) where {S <: BOUNDS} allow_modification(o) v = var(o, VI(ci.value)) # cons index is actually var index lb, ub = bounds(set) @@ -189,11 +189,11 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SVF,S}, set::S) return nothing end -function MOI.is_valid(o::Optimizer, ci::CI{SVF,<:Bounds}) +function MOI.is_valid(o::Optimizer, ci::CI{SVF,<:BOUNDS}) return 1 <= ci.value <= length(o.mscip.vars) end -function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: Bounds} +function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: BOUNDS} if func.constant != 0.0 msg = "SCIP does not support linear constraints with a constant offset." throw(MOI.AddConstraintNotAllowed{SAF, S}(msg)) @@ -215,7 +215,7 @@ function MOI.add_constraint(o::Optimizer, func::SAF, set::S) where {S <: Bounds} return ci end -function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) where {S <: Bounds} +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) where {S <: BOUNDS} allow_modification(o) lhs, rhs = bounds(set) @@ -228,7 +228,7 @@ function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) return nothing end -function MOI.is_valid(o::Optimizer, ci::CI{SAF,<:Bounds}) +function MOI.is_valid(o::Optimizer, ci::CI{SAF,<:BOUNDS}) return 1 <= ci.value <= length(o.mscip.cons) end @@ -236,38 +236,38 @@ function MOI.get(o::Optimizer, ::MOI.NumberOfConstraints{F,S}) where {F,S} return haskey(o.constypes, (F, S)) ? length(o.constypes[F, S]) : 0 end -function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SVF, S}) where S <: Bounds +function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SVF, S}) where S <: BOUNDS return SVF(ci) end -function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SVF, S}) where S <: Bounds +function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SVF, S}) where S <: BOUNDS v = var(o.mscip, ci.value) lb, ub = SCIPvarGetLbOriginal(v), SCIPvarGetUbOriginal(v) return from_bounds(S, lb, ub) end -function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S <: Bounds +function MOI.get(o::Optimizer, ::MOI.ConstraintFunction, ci::CI{SAF, S}) where S <: BOUNDS s, cons = scip(o), cons(o, ci) nvars::Int = SCIPgetNVarsLinear(s, cons) vars = unsafe_wrap(Array{Ptr{SCIP_VAR}}, SCIPgetVarsLinear(s, cons), nvars) vals = unsafe_wrap(Array{Float64}, SCIPgetValsLinear(s, cons), nvars) - terms = [AffTerm(vals[i], VI(ref(o, vars[i]).val)) for i=1:nvars] + terms = [AFF_TERM(vals[i], VI(ref(o, vars[i]).val)) for i=1:nvars] # can not identify constant anymore (is merged with lhs,rhs) return SAF(terms, 0.0) end -function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SAF, S}) where S <: Bounds +function MOI.get(o::Optimizer, ::MOI.ConstraintSet, ci::CI{SAF, S}) where S <: BOUNDS lhs = SCIPgetLhsLinear(scip(o), cons(o, ci)) rhs = SCIPgetRhsLinear(scip(o), cons(o, ci)) return from_bounds(S, lhs, rhs) end -function MOI.get(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:Bounds}) +function MOI.get(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:BOUNDS}) return SCIPconsGetName(cons(o, ci)) end -function MOI.set(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:Bounds}, name::String) +function MOI.set(o::Optimizer, ::MOI.ConstraintName, ci::CI{SAF,<:BOUNDS}, name::String) @SC SCIPchgConsName(scip(o), cons(o, ci), name) return nothing end @@ -295,11 +295,11 @@ function MOI.set(o::Optimizer, ::MOI.ObjectiveFunction{SAF}, obj::SAF) end function MOI.get(o::Optimizer, ::MOI.ObjectiveFunction{SAF}) - terms = AffTerm[] + terms = AFF_TERM[] for i = 1:length(o.mscip.vars) vi = VI(i) coef = SCIPvarGetObj(var(o, vi)) - coef == 0.0 || push!(terms, AffTerm(coef, vi)) + coef == 0.0 || push!(terms, AFF_TERM(coef, vi)) end constant = SCIPgetOrigObjoffset(scip(o)) return SAF(terms, constant) @@ -321,7 +321,7 @@ function MOI.get(o::Optimizer, ::MOI.ObjectiveSense) return SCIPgetObjsense(scip(o)) == SCIP_OBJSENSE_MAXIMIZE ? MOI.MAX_SENSE : MOI.MIN_SENSE end -function MOI.modify(o::Optimizer, ci::CI{SAF, <:Bounds}, +function MOI.modify(o::Optimizer, ci::CI{SAF, <:BOUNDS}, change::MOI.ScalarCoefficientChange{Float64}) allow_modification(o) @SC SCIPchgCoefLinear(scip(o), cons(o, ci), @@ -386,11 +386,11 @@ function MOI.get(o::Optimizer, ::MOI.VariablePrimal, vi::VI) return SCIPgetSolVal(scip(o), SCIPgetBestSol(scip(o)), var(o, vi)) end -function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SVF,<:Bounds}) +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SVF,<:BOUNDS}) return SCIPgetSolVal(scip(o), SCIPgetBestSol(scip(o)), var(o, VI(ci.value))) end -function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SAF,<:Bounds}) +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SAF,<:BOUNDS}) return SCIPgetActivityLinear(scip(o), cons(o, ci), SCIPgetBestSol(scip(o))) end