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/*" 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 index fa18edce..cebcc09e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,23 +1,27 @@ -# Documentation: http://docs.travis-ci.com/user/languages/julia/ +## Documentation: http://docs.travis-ci.com/user/languages/julia/ language: julia -os: - - linux +os: linux +dist: xenial +sudo: true julia: - - 0.7 - 1.0 -dist: trusty -sudo: required -services: - - docker -before_install: - - echo "**** pulling Docker image" - - docker pull leethargo/scip-julia + - nightly notifications: email: false +git: + depth: 99999999 +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 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 + - julia -e 'using Pkg; Pkg.clone(pwd()); Pkg.build("SCIP"); Pkg.test("SCIP"; coverage=true)' 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())' + # push coverage results to Coveralls + - 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 'using Pkg; cd(Pkg.dir("SCIP")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())' 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/README.md b/README.md index d99daec3..3c035233 100644 --- a/README.md +++ b/README.md @@ -1,64 +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) -## 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) -``` +## 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_*.h`.) But the wrapped functions do not transform any data +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 +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 diff --git a/REQUIRE b/REQUIRE index 1e9d1742..8d3c0c00 100644 --- a/REQUIRE +++ b/REQUIRE @@ -1,3 +1,2 @@ -julia 0.7 -BinDeps -MathProgBase 0.5 0.8 +julia 1.0 +MathOptInterface 0.8 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..91405dfe 100644 --- a/deps/build.jl +++ b/deps/build.jl @@ -1,54 +1,41 @@ -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 +depsfile = joinpath(dirname(@__FILE__), "deps.jl") +if isfile(depsfile) + rm(depsfile) 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) +function write_depsfile(path) + f = open(depsfile, "w") + println(f, "const libscip = \"$path\"") + close(f) +end +libname = "libscip.so" +paths_to_try = [] -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) +# prefer environment variable +if haskey(ENV, "SCIPOPTDIR") + if Sys.islinux() + 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) + if d != C_NULL + global found = true + write_depsfile(l) + break + end +end -@BinDeps.install Dict(:libcsip => :libcsip) +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 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/gen/generate_wrapper.jl b/gen/generate_wrapper.jl new file mode 100644 index 00000000..668dc434 --- /dev/null +++ b/gen/generate_wrapper.jl @@ -0,0 +1,31 @@ +using Clang + +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, "scip_"), all_headers), + "scipdefplugins.h", + filter(h -> startswith(h, "cons_"), all_headers), +) +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], +) + +context = Clang.init( + headers=headers, + common_file="commons.jl", + output_dir="../src/wrapper", + clang_includes=vcat(HEADER_BASE, LLVM_INCLUDE), + clang_args = ["-I", HEADER_BASE], + clang_diagnostics=true, + header_wrapped=(header, cursorname) -> header == cursorname, + header_library=header_name -> "libscip" +) +Clang.run(context) diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl new file mode 100644 index 00000000..3169d3cb --- /dev/null +++ b/src/MOI_wrapper.jl @@ -0,0 +1,401 @@ +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 BOUNDS = Union{MOI.EqualTo{Float64}, MOI.GreaterThan{Float64}, + MOI.LessThan{Float64}, MOI.Interval{Float64}} +const VAR_TYPES = Union{MOI.ZeroOne, MOI.Integer} +# other MOI types +const AFF_TERM = MOI.ScalarAffineTerm{Float64} + +const PtrMap = Dict{Ptr{Cvoid}, Union{VarRef, ConsRef}} +const ConsTypeMap = Dict{Tuple{DataType, DataType}, Vector{ConsRef}} + +mutable struct Optimizer <: MOI.AbstractOptimizer + mscip::ManagedSCIP + reference::PtrMap + constypes::ConsTypeMap + params::Dict{String,Any} + + Optimizer() = new(ManagedSCIP(), PtrMap(), ConsTypeMap(), Dict()) +end + + +## convenience functions (not part of MOI) + +"Return pointer to SCIP instance." +scip(o::Optimizer) = scip(o.mscip) + +"Return pointer to SCIP variable." +var(o::Optimizer, v::VI) = var(o.mscip, VarRef(v.value)) + +"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, ConsRef(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) + +"Make set from bounds." +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 <: Union{VarRef, ConsRef} + @assert !haskey(o.reference, ptr) + o.reference[ptr] = ref + return ref +end + +"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], cr) + else + o.constypes[F,S] = [cr] + end + return c +end + +"Go back from solved stage to problem modification stage, invalidating results." +function allow_modification(o::Optimizer) + if SCIPgetStage(scip(o)) != SCIP_STAGE_PROBLEM + @SC SCIPfreeTransform(scip(o)) + end + return nothing +end + +## general queries and support + +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{<:VAR_TYPES}) = true +# linear constraints +MOI.supports_constraint(o::Optimizer, ::Type{SAF}, ::Type{<:BOUNDS}) = true + +MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true +MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{SAF}) = true + +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 + +function MOI.is_empty(o::Optimizer) + return 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() + # clear auxiliary mapping structures + o.reference = PtrMap() + o.constypes = ConsTypeMap() + # reapply parameters + for pair in o.params + set_parameter(o.mscip, pair.first, pair.second) + end + return nothing +end + +function MOI.copy_to(dest::Optimizer, src::MOI.ModelLike; kws...) + return MOIU.automatic_copy_to(dest, src; kws...) +end + +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) + 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] +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(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 +scip_vartype(::Type{MOI.Integer}) = SCIP_VARTYPE_INTEGER +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}} + @SC SCIPchgVarType(scip(o), v, scip_vartype(S), infeasible[]) + if S <: MOI.ZeroOne + # need to adjust bounds for SCIP?! + @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 + return register!(o, CI{SVF, S}(i)) +end + +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) + 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)) +end + +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) + lb == nothing || @SC SCIPchgVarLb(scip(o), v, lb) + ub == nothing || @SC SCIPchgVarUb(scip(o), v, ub) + return nothing +end + +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} + if func.constant != 0.0 + msg = "SCIP does not support linear constraints with a constant offset." + throw(MOI.AddConstraintNotAllowed{SAF, S}(msg)) + end + + allow_modification(o) + + 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 + + cr = add_linear_constraint(o.mscip, varrefs, coefs, lhs, rhs) + ci = CI{SAF, S}(cr.val) + register!(o, ci) + register!(o, cons(o, ci), cr) + return ci +end + +function MOI.set(o::SCIP.Optimizer, ::MOI.ConstraintSet, ci::CI{SAF,S}, set::S) where {S <: BOUNDS} + allow_modification(o) + + lhs, rhs = bounds(set) + lhs = lhs == nothing ? -SCIPinfinity(scip(o)) : lhs + rhs = rhs == nothing ? SCIPinfinity(scip(o)) : rhs + + @SC SCIPchgLhsLinear(scip(o), cons(o, ci), lhs) + @SC SCIPchgRhsLinear(scip(o), cons(o, ci), rhs) + + return nothing +end + +function MOI.is_valid(o::Optimizer, ci::CI{SAF,<:BOUNDS}) + return 1 <= ci.value <= length(o.mscip.cons) +end + +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 + 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) + return from_bounds(S, lb, ub) +end + +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 = [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 + 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}) + 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) + allow_modification(o) + s = scip(o) + + # reset objective coefficient of all variables first + for v in o.mscip.vars + @SC SCIPchgVarObj(s, v[], 0.0) + end + + # set new objective coefficients, summing coefficients + for t in obj.terms + v = var(o, t.variable_index) + oldcoef = SCIPvarGetObj(v) + newcoef = oldcoef + t.coefficient + @SC SCIPchgVarObj(s, v, newcoef) + end + + @SC SCIPaddOrigObjoffset(s, obj.constant - SCIPgetOrigObjoffset(s)) + + return nothing +end + +function MOI.get(o::Optimizer, ::MOI.ObjectiveFunction{SAF}) + terms = AFF_TERM[] + for i = 1:length(o.mscip.vars) + vi = VI(i) + coef = SCIPvarGetObj(var(o, vi)) + coef == 0.0 || push!(terms, AFF_TERM(coef, vi)) + end + 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(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 + +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}, + 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::MOI.ScalarCoefficientChange{Float64}) + allow_modification(o) + @SC SCIPchgVarObj(scip(o), var(o, change.variable), change.new_coefficient) + return nothing +end + +## optimization and results + +function MOI.optimize!(o::Optimizer) + @SC SCIPsolve(scip(o)) + 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.OPTIMAL, + 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) + return term_status_map[SCIPgetStatus(scip(o))] +end + +function MOI.get(o::Optimizer, ::MOI.PrimalStatus) + return SCIPgetNSols(scip(o)) > 0 ? MOI.FEASIBLE_POINT : MOI.NO_SOLUTION +end + +function MOI.get(o::Optimizer, ::MOI.ResultCount) + status = SCIPgetStatus(scip(o)) + if status in [SCIP_STATUS_UNBOUNDED, SCIP_STATUS_INFORUNBD] + return 0 + end + return SCIPgetNSols(scip(o)) +end + +function MOI.get(o::Optimizer, ::MOI.ObjectiveValue) + return SCIPgetSolOrigObj(scip(o), SCIPgetBestSol(scip(o))) +end + +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}) + return SCIPgetSolVal(scip(o), SCIPgetBestSol(scip(o)), var(o, VI(ci.value))) +end + +function MOI.get(o::Optimizer, ::MOI.ConstraintPrimal, ci::CI{SAF,<:BOUNDS}) + return SCIPgetActivityLinear(scip(o), cons(o, ci), SCIPgetBestSol(scip(o))) +end + +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/SCIP.jl b/src/SCIP.jl index ed132896..62d40da8 100644 --- a/src/SCIP.jl +++ b/src/SCIP.jl @@ -1,39 +1,35 @@ 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\")") +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) -include("../deps/csip_version.jl") - -using SparseArrays: issparse, findnz +function __init__() + major = SCIPmajorVersion() + minor = SCIPminorVersion() + patch = SCIPtechVersion() + current = VersionNumber("$major.$minor.$patch") + required = VersionNumber("6.0.0") + 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 -import MathProgBase -import MathProgBase.SolverInterface: AbstractLinearQuadraticModel, - AbstractNonlinearModel, - AbstractMathProgSolver, - MathProgCallbackData, - AbstractNLPEvaluator, - LinearQuadraticModel +# wrapper of SCIP library +include("wrapper.jl") -include("types.jl") -include("csip_wrapper.jl") -include("scip_wrapper.jl") -include("mpb_interface.jl") -include("params.jl") +# memory management +include("managed_scip.jl") -function CSIPversion() - VersionNumber("$(_majorVersion()).$(_minorVersion()).$(_patchVersion())") -end +# implementation of MOI +include("MOI_wrapper.jl") -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 +# 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 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/managed_scip.jl b/src/managed_scip.jl new file mode 100644 index 00000000..dcaf5f92 --- /dev/null +++ b/src/managed_scip.jl @@ -0,0 +1,95 @@ +"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}}} + conss::Vector{Ref{Ptr{SCIP_CONS}}} + + function ManagedSCIP() + scip = Ref{Ptr{SCIP_}}() + @SC SCIPcreate(scip) + @assert scip[] != C_NULL + @SC SCIPincludeDefaultPlugins(scip[]) + @SC SCIP.SCIPcreateProbBasic(scip[], "") + + mscip = new(scip, [], []) + finalizer(free_scip, mscip) + end +end + +"Release references and free memory." +function free_scip(mscip::ManagedSCIP) + # Avoid double-free (SCIP will set the pointers to NULL). + s = scip(mscip) + if s != C_NULL + for c in mscip.conss + @SC SCIPreleaseCons(s, c) + end + for v in mscip.vars + @SC SCIPreleaseVar(s, v) + end + @SC SCIPfree(mscip.scip) + end + @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 + +"Return pointer to SCIP instance." +scip(mscip::ManagedSCIP) = mscip.scip[] + +"Return pointer to SCIP variable." +var(mscip::ManagedSCIP, vr::VarRef) = mscip.vars[vr.val][] + +"Return pointer to SCIP constraint." +cons(mscip::ManagedSCIP, cr::ConsRef) = mscip.conss[cr.val][] + +"Add variable to problem (continuous, no bounds), return var ref." +function add_variable(mscip::ManagedSCIP) + 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__) + # can't delete variable, so we use the array position as index + return VarRef(length(mscip.vars)) +end + +""" +Add (ranged) linear constraint to problem, return cons ref. + +# Arguments +- `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, 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__[]) + + push!(mscip.conss, cons__) + # can't delete constraint, so we use the array position as index + return ConsRef(length(mscip.conss)) +end + +"Set generic parameter." +function set_parameter(mscip::ManagedSCIP, name::String, value) + @SC SCIPsetParam(scip(mscip), name, Ptr{Cvoid}(value)) + return nothing +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/src/wrapper.jl b/src/wrapper.jl new file mode 100644 index 00000000..ddadcb6d --- /dev/null +++ b/src/wrapper.jl @@ -0,0 +1,138 @@ +wrap(base) = joinpath("wrapper", base * ".jl") + +# used by Clang.jl +include(wrap("ctypes")) +include(wrap("CEnum")) +using .CEnum + +# all type definitions +include(wrap("manual_commons")) +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")) + +# 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")) +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")) + +# SCIP_CALL: macro to check return codes, inspired by @assert +macro SC(ex) + return :(@assert $(esc(ex)) == SCIP_OKAY) +end diff --git a/src/wrapper/CEnum.jl b/src/wrapper/CEnum.jl new file mode 100644 index 00000000..29eb16ee --- /dev/null +++ b/src/wrapper/CEnum.jl @@ -0,0 +1,116 @@ +# Copyright (c) 2018 Isaiah Norton and other [contributors](https://github.com/ihnorton/Clang.jl/graphs/contributors) + +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/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. diff --git a/src/wrapper/commons.jl b/src/wrapper/commons.jl new file mode 100644 index 00000000..0ce24089 --- /dev/null +++ b/src/wrapper/commons.jl @@ -0,0 +1,1504 @@ +# Automatically generated using Clang.jl wrap_c + + +# 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_BENDERSENFOTYPE = SCIP_BendersEnfoType + +@cenum(SCIP_BendersSolveLoop, + SCIP_BENDERSSOLVELOOP_CONVEX = 0, + SCIP_BENDERSSOLVELOOP_CIP = 1, + SCIP_BENDERSSOLVELOOP_USERCONVEX = 2, + SCIP_BENDERSSOLVELOOP_USERCIP = 3, +) + +const SCIP_BENDERSSOLVELOOP = SCIP_BendersSolveLoop + +@cenum(SCIP_BendersSubStatus, + SCIP_BENDERSSUBSTATUS_UNKNOWN = 0, + SCIP_BENDERSSUBSTATUS_OPTIMAL = 1, + SCIP_BENDERSSUBSTATUS_AUXVIOL = 2, + SCIP_BENDERSSUBSTATUS_INFEAS = 3, +) + +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, +) + +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, +) + +const SCIP_CONFTYPE = SCIP_ConflictType + +@cenum(SCIP_ConflictPresolStrat, + SCIP_CONFPRES_DISABLED = 0, + SCIP_CONFPRES_ONLYLOCAL = 1, + SCIP_CONFPRES_ONLYGLOBAL = 2, + SCIP_CONFPRES_BOTH = 3, +) + +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_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, +) + +const SCIP_DISPSTATUS = SCIP_DispStatus + +@cenum(SCIP_DispMode, + SCIP_DISPMODE_DEFAULT = 1, + SCIP_DISPMODE_CONCURRENT = 2, + SCIP_DISPMODE_ALL = 3, +) + +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 + +# 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 ) + +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) + +# 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 ) + +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_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, +) + +const SCIP_LPSOLSTAT = SCIP_LPSolStat + +@cenum(SCIP_BoundType, + SCIP_BOUNDTYPE_LOWER = 0, + SCIP_BOUNDTYPE_UPPER = 1, +) + +const SCIP_BOUNDTYPE = SCIP_BoundType + +@cenum(SCIP_SideType, + SCIP_SIDETYPE_LEFT = 0, + SCIP_SIDETYPE_RIGHT = 1, +) + +const SCIP_SIDETYPE = SCIP_SideType + +@cenum(SCIP_RowOriginType, + SCIP_ROWORIGINTYPE_UNSPEC = 0, + SCIP_ROWORIGINTYPE_CONS = 1, + SCIP_ROWORIGINTYPE_SEPA = 2, + SCIP_ROWORIGINTYPE_REOPT = 3, +) + +const SCIP_ROWORIGINTYPE = SCIP_RowOriginType + +@cenum(SCIP_LPAlgo, + SCIP_LPALGO_PRIMALSIMPLEX = 0, + SCIP_LPALGO_DUALSIMPLEX = 1, + SCIP_LPALGO_BARRIER = 2, + SCIP_LPALGO_BARRIERCROSSOVER = 3, +) + +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_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, +) + +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_PARAMTYPE = SCIP_ParamType + +@cenum(SCIP_ParamSetting, + SCIP_PARAMSETTING_DEFAULT = 0, + SCIP_PARAMSETTING_AGGRESSIVE = 1, + SCIP_PARAMSETTING_FAST = 2, + SCIP_PARAMSETTING_OFF = 3, +) + +const SCIP_PARAMSETTING = SCIP_ParamSetting + +@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_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, +) + +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_REOPTTYPE = SCIP_ReoptType + +@cenum(Reopt_ConsType, + REOPT_CONSTYPE_INFSUBTREE = 0, + REOPT_CONSTYPE_DUALREDS = 1, + REOPT_CONSTYPE_CUT = 2, + REOPT_CONSTYPE_UNKNOWN = 3, +) + +const REOPT_CONSTYPE = Reopt_ConsType + +@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_RESULT = SCIP_Result + +@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_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, +) + +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_STAGE = SCIP_Stage + +@cenum(SCIP_Setting, + SCIP_UNDEFINED = 0, + SCIP_DISABLED = 1, + SCIP_AUTO = 2, + SCIP_ENABLED = 3, +) + +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, +) + +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_STATUS = SCIP_Status +const SCIP_Stat = Cvoid +const SCIP_STAT = SCIP_Stat + +@cenum(SCIP_Parallelmode, + SCIP_PARA_OPPORTUNISTIC = 0, + SCIP_PARA_DETERMINISTIC = 1, +) + +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) +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) +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) +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) +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 + +@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_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 ) +# 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 + +@cenum(SCIP_Vartype, + SCIP_VARTYPE_BINARY = 0, + SCIP_VARTYPE_INTEGER = 1, + SCIP_VARTYPE_IMPLINT = 2, + SCIP_VARTYPE_CONTINUOUS = 3, +) + +const SCIP_VARTYPE = SCIP_Vartype + +@cenum(SCIP_DomchgType, + SCIP_DOMCHGTYPE_DYNAMIC = 0, + SCIP_DOMCHGTYPE_BOTH = 1, + SCIP_DOMCHGTYPE_BOUND = 2, +) + +const SCIP_DOMCHGTYPE = SCIP_DomchgType + +@cenum(SCIP_BoundchgType, + SCIP_BOUNDCHGTYPE_BRANCHING = 0, + SCIP_BOUNDCHGTYPE_CONSINFER = 1, + SCIP_BOUNDCHGTYPE_PROPINFER = 2, +) + +const SCIP_BOUNDCHGTYPE = SCIP_BoundchgType + +@cenum(SCIP_LockType, + SCIP_LOCKTYPE_MODEL = 0, + SCIP_LOCKTYPE_CONFLICT = 1, +) + +const SCIP_LOCKTYPE = SCIP_LockType +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 +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 ) +# 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__ ) + +@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, +) + +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 ) +# 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 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 diff --git a/src/wrapper/ctypes.jl b/src/wrapper/ctypes.jl new file mode 100644 index 00000000..6c11d67b --- /dev/null +++ b/src/wrapper/ctypes.jl @@ -0,0 +1,9 @@ +# 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 + +const Ctm = Base.Libc.TmStruct +const Ctime_t = UInt +const Cclock_t = UInt diff --git a/src/wrapper/manual_commons.jl b/src/wrapper/manual_commons.jl new file mode 100644 index 00000000..96107337 --- /dev/null +++ b/src/wrapper/manual_commons.jl @@ -0,0 +1,46 @@ +# 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" + +const FILE = Cvoid + +const BMS_BLKMEM = Cvoid +const BMS_BUFMEM = Cvoid + +const SCIP_Bool = Cuint +const SCIP_Real = Cdouble 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 diff --git a/src/wrapper/scip_bandit.jl b/src/wrapper/scip_bandit.jl new file mode 100644 index 00000000..9dd215be --- /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 + + +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) + 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..0cc02456 --- /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 + + +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, 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) +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) + 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) + 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) +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) + 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) + 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) +end + +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, 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) +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) +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) +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) +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) +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) + 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..b38f37a6 --- /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 + + +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, 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) +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) + 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) +end + +function SCIPsetBranchruleMaxbounddist(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) +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, 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) +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, 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) +end + +function SCIPgetBranchingPoint(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) +end + +function SCIPcalcChildEstimate(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) +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, 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) +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) +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..4498dfc3 --- /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 + + +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, 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) +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) + 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..5085788e --- /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 + + +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 + +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..d8e7af67 --- /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 + + +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, 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) + 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, 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) +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) +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) + 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) +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) +end + +function SCIPaddConflictBinvar(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) +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, 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..abedccb2 --- /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 + + +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, 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) +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) +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, 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, 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) +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) + 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) +end + +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) + 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) +end + +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) + 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) +end + +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) + 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, 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, 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) +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, 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) +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) +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) +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) +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) +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, 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) +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) +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, 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..f14710a0 --- /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 + + +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 + +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, 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, 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) +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) +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) +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) +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) +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) +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) +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) +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) +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) +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) + 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) +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) +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) +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) +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..584d3870 --- /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 + + +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) + 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) +end + +function SCIPisCutApplicable(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) +end + +function SCIPaddRow(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) +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) + 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, 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) +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..ed143141 --- /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 + + +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, 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) +end + +function SCIPgetRealarrayVal(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) +end + +function SCIPincRealarrayVal(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) +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, 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) +end + +function SCIPgetIntarrayVal(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) +end + +function SCIPincIntarrayVal(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) +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, 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) +end + +function SCIPgetBoolarrayVal(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) +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, 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) +end + +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, 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) + 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) + 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..721472f0 --- /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 + + +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..159f6e54 --- /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 + + +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 + +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..a1cd1bd8 --- /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 + + +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 + +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) + 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..459973df --- /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 + + +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, 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) +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) +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) +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) +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) +end diff --git a/src/wrapper/scip_expr.jl b/src/wrapper/scip_expr.jl new file mode 100644 index 00000000..d78b4388 --- /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 + + +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, 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) +end diff --git a/src/wrapper/scip_general.jl b/src/wrapper/scip_general.jl new file mode 100644 index 00000000..43a646d6 --- /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 + + +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) + 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..a3a575c5 --- /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 + + +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, 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) +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) + 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) +end diff --git a/src/wrapper/scip_lp.jl b/src/wrapper/scip_lp.jl new file mode 100644 index 00000000..4aa6d855 --- /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 + + +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, 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) +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) +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) +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, 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) +end + +function SCIPprintLPSolutionQuality(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) +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, 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) +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) +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) +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) +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) +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) +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) +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) + 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) +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) + 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) +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) +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) +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) +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) + 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) +end + +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) + 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) + 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) +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, 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..24e59334 --- /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 + + +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) + 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) +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..22db6ee8 --- /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 + + +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) + 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..bab3d803 --- /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 + + +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) + 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, 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) +end + +function SCIPgetNLPRealPar(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) +end + +function SCIPgetNLPStringPar(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) +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) + 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) +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) +end + +function SCIPsolveDiveNLP(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) +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) +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) + 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) +end + +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) + 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) +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) +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, 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) +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) +end + +function SCIPchgNlRowQuadElement(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) +end + +function SCIPsetNlRowExprtreeParam(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) +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..6490e94c --- /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 + + +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, 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) +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) + 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) +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..dd88e7df --- /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 + + +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, 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) +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) +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) +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) +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) +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) +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) +end diff --git a/src/wrapper/scip_numerics.jl b/src/wrapper/scip_numerics.jl new file mode 100644 index 00000000..9d03b69f --- /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 + + +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) + 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) +end + +function SCIPchgDualfeastol(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) +end + +function SCIPchgRelaxfeastol(scip, relaxfeastol) + 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, 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) +end + +function SCIPisLE(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) +end + +function SCIPisGE(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) +end + +function SCIPisHugeValue(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) +end + +function SCIPisPositive(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) +end + +function SCIPisIntegral(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) +end + +function SCIPisFracIntegral(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) +end + +function SCIPceil(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) +end + +function SCIPfrac(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) +end + +function SCIPisSumLT(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) +end + +function SCIPisSumGT(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) +end + +function SCIPisSumZero(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) +end + +function SCIPisSumNegative(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) +end + +function SCIPisFeasLT(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) +end + +function SCIPisFeasGT(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) +end + +function SCIPisFeasZero(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) +end + +function SCIPisFeasNegative(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) +end + +function SCIPisFeasFracIntegral(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) +end + +function SCIPfeasCeil(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) +end + +function SCIPfeasFrac(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) +end + +function SCIPisDualfeasLT(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) +end + +function SCIPisDualfeasGT(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) +end + +function SCIPisDualfeasZero(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) +end + +function SCIPisDualfeasNegative(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) +end + +function SCIPisDualfeasFracIntegral(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) +end + +function SCIPdualfeasCeil(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) +end + +function SCIPdualfeasFrac(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) +end + +function SCIPisUbBetter(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) +end + +function SCIPisRelLT(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) +end + +function SCIPisRelGT(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) +end + +function SCIPisSumRelEQ(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) +end + +function SCIPisSumRelLE(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) +end + +function SCIPisSumRelGE(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) +end + +function SCIPconvertRealToLongint(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) +end + +function SCIPprintReal(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) +end diff --git a/src/wrapper/scip_param.jl b/src/wrapper/scip_param.jl new file mode 100644 index 00000000..d958a552 --- /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 + + +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, 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) +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) +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) +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) +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) + 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) +end + +function SCIPisBoolParamValid(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) +end + +function SCIPsetIntParam(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) +end + +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) + 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) +end + +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) + 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) +end + +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) + 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) +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, 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) +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, 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) +end + +function SCIPsetHeuristics(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) +end + +function SCIPsetSeparating(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) +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..693c95f2 --- /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 + + +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, 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) +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) + 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..6e07a773 --- /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 + + +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, 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) +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) + 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..41142d35 --- /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 + + +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) + 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) +end + +function SCIPfreeProb(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) +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, 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) +end + +function SCIPsetObjsense(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) +end + +function SCIPaddOrigObjoffset(scip, addval) + 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) + 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) + 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, 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) +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) + 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) +end + +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) + 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) +end diff --git a/src/wrapper/scip_probing.jl b/src/wrapper/scip_probing.jl new file mode 100644 index 00000000..30dc4942 --- /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 + + +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) + 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) + 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) +end + +function SCIPgetVarObjProbing(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) +end + +function SCIPchgVarObjProbing(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) +end + +function SCIPpropagateProbing(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) +end + +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, 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) +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, 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) +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) +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, 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) +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..0cebec76 --- /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 + + +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, 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) +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, 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) +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) + 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) +end diff --git a/src/wrapper/scip_randnumgen.jl b/src/wrapper/scip_randnumgen.jl new file mode 100644 index 00000000..6209360f --- /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 + + +function SCIPcreateRandom(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) +end + +function SCIPsetRandomSeed(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) +end diff --git a/src/wrapper/scip_reader.jl b/src/wrapper/scip_reader.jl new file mode 100644 index 00000000..321e6ebb --- /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 + + +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..507b8755 --- /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 + + +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, 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) +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) + 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..bc1d8e04 --- /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 + + +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, 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) + 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) +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) +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) +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) +end + +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) + 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) +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) +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, 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) +end diff --git a/src/wrapper/scip_sepa.jl b/src/wrapper/scip_sepa.jl new file mode 100644 index 00000000..8cc68cc7 --- /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 + + +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, 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) +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) + 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..461fa62f --- /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 + + +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) + 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) +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) +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, 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) + ccall((:SCIPtransformObj, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, obj) +end + +function SCIPretransformObj(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) +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) + 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) +end + +function SCIPprintTransSol(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) +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) + 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) +end + +function SCIPprintRay(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) +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) + 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) +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, 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, 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) +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) +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, 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) +end + +function SCIPupdateSolIntegralityViolation(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) +end + +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, 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) +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..af58ec17 --- /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 + + +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) + 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) + 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, 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) +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, 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) +end + +function SCIPgetReoptOldObjCoef(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) +end diff --git a/src/wrapper/scip_solvingstats.jl b/src/wrapper/scip_solvingstats.jl new file mode 100644 index 00000000..9061aa47 --- /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 + + +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) + 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) + 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) + ccall((:SCIPgetAvgPseudocost, libscip), Cdouble, (Ptr{SCIP_}, Cdouble), scip, solvaldelta) +end + +function SCIPgetAvgPseudocostCurrentRun(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) +end + +function SCIPgetAvgPseudocostCountCurrentRun(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) +end + +function SCIPgetAvgPseudocostScore(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) +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) + 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) +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) + 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) +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) + 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) +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, 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) +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..1d889a33 --- /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 + + +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 + +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..19e76961 --- /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 + + +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) + 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..ee8b137a --- /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 + + +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) + 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..7fb13a1f --- /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 + + +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 new file mode 100644 index 00000000..07fbde15 --- /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 + + +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, 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) +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) +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) +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) +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) +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, 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) +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) + 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, 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, 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, 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, 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, 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) +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) +end + +function SCIPgetVarRedcost(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) +end + +function SCIPgetVarFarkasCoef(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) +end + +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, 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) +end + +function SCIPgetVarSol(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) +end + +function SCIPclearRelaxSolVals(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) +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) +end + +function SCIPsetRelaxSolValsSol(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) +end + +function SCIPmarkRelaxSolValid(scip, includeslp) + 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) + 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, 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) +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) +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) +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) +end + +function SCIPgetLastStrongbranchLPSolStat(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, 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) +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, 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) +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) +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) +end + +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) + 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) +end + +function SCIPadjustedVarUb(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) +end + +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) + 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) +end + +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) + 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) +end + +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, 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) +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) +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) +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) +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) +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) +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) +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) +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) +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) +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) +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, 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) +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) +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) +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) +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) +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, 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) +end + +function SCIPremoveVarFromGlobalStructures(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) +end + +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) + 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) +end + +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) + 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) +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) +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) +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) +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) +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, 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) +end + +function SCIPgetVarPseudocostValCurrentRun(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) +end + +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) + 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) +end + +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, 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) +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) +end + +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) + 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) +end + +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) + 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) + 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) +end + +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) + 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, 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) +end + +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) + 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) + 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) +end + +function SCIPprintVar(scip, var, file) + ccall((:SCIPprintVar, libscip), SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_VAR}, Ptr{FILE}), scip, var, file) +end 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 diff --git a/test/MOI_wrapper.jl b/test/MOI_wrapper.jl new file mode 100644 index 00000000..4b829682 --- /dev/null +++ b/test/MOI_wrapper.jl @@ -0,0 +1,28 @@ +using MathOptInterface +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 + excluded = [ + "linear1", # needs MOI.delete + "linear5", # needs MOI.delete + "linear7", # needs MOI.VectorAffineFunction + "linear11", # needs MOI.delete + "linear13", # TODO: support MOI.FEASIBILITY_SENSE + "linear14", # needs MOI.delete + "linear15", # needs MOI.VectorAffineFunction + ] + MOIT.contlineartest(optimizer, config, excluded) +end + +@testset "MOI Integer Linear" begin + excluded = [ + "int2", # TODO: implement SOS1, SOS2 + ] + MOIT.intlineartest(optimizer, config, excluded) +end diff --git a/test/REQUIRE b/test/REQUIRE deleted file mode 100644 index 7d68054c..00000000 --- a/test/REQUIRE +++ /dev/null @@ -1 +0,0 @@ -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/direct_library_calls.jl b/test/direct_library_calls.jl new file mode 100644 index 00000000..fe093c2b --- /dev/null +++ b/test/direct_library_calls.jl @@ -0,0 +1,69 @@ +# Test raw wrapper with direct library calls + +@testset "create small problem and solve" begin + scip__ = Ref{Ptr{SCIP.SCIP_}}() # SCIP** + rc = SCIP.SCIPcreate(scip__) + @test rc == SCIP.SCIP_OKAY + + scip_ = scip__[] # dereference to SCIP* + @test scip_ != C_NULL + + rc = SCIP.SCIPincludeDefaultPlugins(scip_) + @test rc == SCIP.SCIP_OKAY + + # disable output + 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 >= 0, objcoef: 1 + var__ = Ref{Ptr{SCIP.SCIP_VAR}}() + rc = SCIP.SCIPcreateVarBasic(scip_, var__, "x", + 0.0, SCIP.SCIPinfinity(scip_), + 1.0, SCIP.SCIP_VARTYPE_CONTINUOUS) + @test rc == SCIP.SCIP_OKAY + var_ = var__[] + @test var_ != C_NULL + rc = SCIP.SCIPaddVar(scip_, var_) + @test rc == SCIP.SCIP_OKAY + + # add constraint: 2x >= 3 ( really: 3 <= 2 * x <= inf ) + 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 + 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 + + # check solution value + sol_ = SCIP.SCIPgetBestSol(scip_) + @test sol_ != C_NULL + val = SCIP.SCIPgetSolVal(scip_, sol_, var_) + @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__) + @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 diff --git a/test/managed_scip.jl b/test/managed_scip.jl new file mode 100644 index 00000000..3dbbc378 --- /dev/null +++ b/test/managed_scip.jl @@ -0,0 +1,56 @@ +# Test memory management + +@testset "create and manual free" begin + 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 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 + +@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 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..04670db4 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,16 +1,14 @@ using Test using SCIP -using MathProgBase -using JuMP -@testset "MathProgBase tests" begin - include("mpb_tests.jl") +@testset "direct library calls" begin + include("direct_library_calls.jl") end -@testset "CSIP tests" begin - include("csip_tests.jl") +@testset "managed memory" begin + include("managed_scip.jl") end -@testset "Other tests" begin - include("more_tests.jl") +@testset "MathOptInterface tests" begin + include("MOI_wrapper.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