From 5491726ddb8609357edfa21bcbd389bfd4b2d167 Mon Sep 17 00:00:00 2001 From: matbesancon Date: Wed, 26 Nov 2025 09:00:30 +0100 Subject: [PATCH 1/3] update deps --- Project.toml | 4 ++-- src/init.jl | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Project.toml b/Project.toml index 5c9c0f51..bbacb505 100644 --- a/Project.toml +++ b/Project.toml @@ -13,8 +13,8 @@ SCIP_jll = "e5ac4fe4-a920-5659-9bf8-f9f73e9e79ce" [compat] MathOptInterface = "1.32" OpenBLAS32_jll = "0.3" -SCIP_PaPILO_jll = "900.200.101" -SCIP_jll = "900.200.101" +SCIP_PaPILO_jll = "900.200.101, 1000" +SCIP_jll = "900.200.101, 1000" julia = "1.10" [extras] diff --git a/src/init.jl b/src/init.jl index 9fb0f4d1..3a91edc7 100644 --- a/src/init.jl +++ b/src/init.jl @@ -29,7 +29,7 @@ function __init__() patch = SCIPtechVersion() current = VersionNumber("$major.$minor.$patch") required = VersionNumber("9") - upperbound = VersionNumber("10") + upperbound = VersionNumber("11") if current < required || current >= upperbound @error( "SCIP is installed at version $current, " * From b83c536883979d8f881f164eac4fd6fe06c6482c Mon Sep 17 00:00:00 2001 From: matbesancon Date: Thu, 8 Jan 2026 13:28:34 +0100 Subject: [PATCH 2/3] readapt headers --- Project.toml | 4 +- src/LibSCIP.jl | 66724 +++++++++++------------------------------------ 2 files changed, 14640 insertions(+), 52088 deletions(-) diff --git a/Project.toml b/Project.toml index bbacb505..35bcdde9 100644 --- a/Project.toml +++ b/Project.toml @@ -13,8 +13,8 @@ SCIP_jll = "e5ac4fe4-a920-5659-9bf8-f9f73e9e79ce" [compat] MathOptInterface = "1.32" OpenBLAS32_jll = "0.3" -SCIP_PaPILO_jll = "900.200.101, 1000" -SCIP_jll = "900.200.101, 1000" +SCIP_PaPILO_jll = "1000" +SCIP_jll = "1000" julia = "1.10" [extras] diff --git a/src/LibSCIP.jl b/src/LibSCIP.jl index e69f4dd4..71c6ffb2 100644 --- a/src/LibSCIP.jl +++ b/src/LibSCIP.jl @@ -1,8 +1,3 @@ -# Copyright (c) 2018 Felipe Serrano, Miles Lubin, Robert Schwarz, and contributors -# -# Use of this source code is governed by an MIT-style license that can be found -# in the LICENSE.md file or at https://opensource.org/licenses/MIT. - module LibSCIP using ..SCIP: libscip @@ -16,6 +11,7 @@ const SIZE_MAX = typemax(Csize_t) const UINT64_C = UInt64 const UINT32_C = UInt32 + @enum SCIP_Retcode::Int32 begin SCIP_OKAY = 1 SCIP_ERROR = 0 @@ -137,6 +133,13 @@ end const SCIP_BENDERSSUBTYPE = SCIP_BendersSubType +@enum SCIP_BendersObjectiveType::UInt32 begin + SCIP_BENDERSOBJTYPE_SUM = 0 + SCIP_BENDERSOBJTYPE_MAX = 1 +end + +const SCIP_BENDERSOBJTYPE = SCIP_BendersObjectiveType + const SCIP_BendersData = Cvoid const SCIP_BENDERSDATA = SCIP_BendersData @@ -169,6 +172,26 @@ const SCIP_Treemodel = Cvoid const SCIP_TREEMODEL = SCIP_Treemodel +const SCIP_Certnodedata = Cvoid + +const SCIP_CERTNODEDATA = SCIP_Certnodedata + +const SCIP_AggregationInfo = Cvoid + +const SCIP_AGGREGATIONINFO = SCIP_AggregationInfo + +const SCIP_MirInfo = Cvoid + +const SCIP_MIRINFO = SCIP_MirInfo + +const SCIP_Certificate = Cvoid + +const SCIP_CERTIFICATE = SCIP_Certificate + +const SCIP_CertificateBound = Cvoid + +const SCIP_CERTIFICATEBOUND = SCIP_CertificateBound + @enum SCIP_ClockType::UInt32 begin SCIP_CLOCKTYPE_DEFAULT = 0 SCIP_CLOCKTYPE_CPU = 1 @@ -229,7 +252,95 @@ const SCIP_Conflicthdlr = Cvoid const SCIP_CONFLICTHDLR = SCIP_Conflicthdlr -const SCIP_Node = Cvoid +const SCIP_Rational = Cvoid + +const SCIP_RATIONAL = SCIP_Rational + +struct __JL_Ctag_87 + data::NTuple{8, UInt8} +end + +function Base.getproperty(x::Ptr{__JL_Ctag_87}, f::Symbol) + f === :probingnode && return Ptr{Ptr{SCIP_PROBINGNODE}}(x + 0) + f === :sibling && return Ptr{SCIP_SIBLING}(x + 0) + f === :child && return Ptr{SCIP_CHILD}(x + 0) + f === :leaf && return Ptr{SCIP_LEAF}(x + 0) + f === :junction && return Ptr{SCIP_JUNCTION}(x + 0) + f === :pseudofork && return Ptr{Ptr{SCIP_PSEUDOFORK}}(x + 0) + f === :fork && return Ptr{Ptr{SCIP_FORK}}(x + 0) + f === :subroot && return Ptr{Ptr{SCIP_SUBROOT}}(x + 0) + return getfield(x, f) +end + +function Base.getproperty(x::__JL_Ctag_87, f::Symbol) + r = Ref{__JL_Ctag_87}(x) + ptr = Base.unsafe_convert(Ptr{__JL_Ctag_87}, r) + fptr = getproperty(ptr, f) + GC.@preserve r unsafe_load(fptr) +end + +function Base.setproperty!(x::Ptr{__JL_Ctag_87}, f::Symbol, v) + unsafe_store!(getproperty(x, f), v) +end + +function Base.propertynames(x::__JL_Ctag_87, private::Bool = false) + (:probingnode, :sibling, :child, :leaf, :junction, :pseudofork, :fork, :subroot, if private + fieldnames(typeof(x)) + else + () + end...) +end + +const SCIP_ConsSetChg = Cvoid + +const SCIP_CONSSETCHG = SCIP_ConsSetChg + +const SCIP_DomChg = Cvoid + +const SCIP_DOMCHG = SCIP_DomChg + +struct SCIP_Node + data::NTuple{80, UInt8} +end + +function Base.getproperty(x::Ptr{SCIP_Node}, f::Symbol) + f === :number && return Ptr{Clonglong}(x + 0) + f === :lowerbound && return Ptr{Cdouble}(x + 8) + f === :lowerboundexact && return Ptr{Ptr{SCIP_RATIONAL}}(x + 16) + f === :estimate && return Ptr{Cdouble}(x + 24) + f === :data && return Ptr{__JL_Ctag_87}(x + 32) + f === :parent && return Ptr{Ptr{SCIP_NODE}}(x + 40) + f === :conssetchg && return Ptr{Ptr{SCIP_CONSSETCHG}}(x + 48) + f === :domchg && return Ptr{Ptr{SCIP_DOMCHG}}(x + 56) + f === :depth && return (Ptr{Cuint}(x + 64), 0, 30) + f === :reoptid && return (Ptr{Cuint}(x + 68), 0, 32) + f === :reopttype && return (Ptr{Cuint}(x + 72), 0, 3) + f === :repropsubtreemark && return (Ptr{Cuint}(x + 72), 3, 9) + f === :active && return (Ptr{Cuint}(x + 72), 12, 1) + f === :cutoff && return (Ptr{Cuint}(x + 72), 13, 1) + f === :reprop && return (Ptr{Cuint}(x + 72), 14, 1) + f === :nodetype && return (Ptr{Cuint}(x + 72), 15, 4) + return getfield(x, f) +end + +function Base.getproperty(x::SCIP_Node, f::Symbol) + r = Ref{SCIP_Node}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_Node}, r) + fptr = getproperty(ptr, f) + GC.@preserve r unsafe_load(fptr) +end + +function Base.setproperty!(x::Ptr{SCIP_Node}, f::Symbol, v) + unsafe_store!(getproperty(x, f), v) +end + +function Base.propertynames(x::SCIP_Node, private::Bool = false) + (:number, :lowerbound, :lowerboundexact, :estimate, :data, :parent, :conssetchg, :domchg, :depth, :reoptid, :reopttype, :repropsubtreemark, :active, :cutoff, :reprop, :nodetype, if private + fieldnames(typeof(x)) + else + () + end...) +end const SCIP_NODE = SCIP_Node @@ -260,6 +371,10 @@ const SCIP_ProofSet = Cvoid const SCIP_PROOFSET = SCIP_ProofSet +const SCIP_ConflictRow = Cvoid + +const SCIP_CONFLICTROW = SCIP_ConflictRow + const SCIP_LPBdChgs = Cvoid const SCIP_LPBDCHGS = SCIP_LPBdChgs @@ -323,13 +438,13 @@ const SCIP_Diveset = Cvoid const SCIP_DIVESET = SCIP_Diveset -const SCIP_ConshdlrData = Cvoid +const SYM_Graph = Cvoid -const SCIP_CONSHDLRDATA = SCIP_ConshdlrData +const SYM_GRAPH = SYM_Graph -const SCIP_ConsSetChg = Cvoid +const SCIP_ConshdlrData = Cvoid -const SCIP_CONSSETCHG = SCIP_ConsSetChg +const SCIP_CONSHDLRDATA = SCIP_ConshdlrData const SCIP_LinConsStats = Cvoid @@ -378,6 +493,7 @@ struct SCIP_AggrRow rowssize::Cint rank::Cint _local::Cuint + certificateline::Clonglong end const SCIP_AGGRROW = SCIP_AggrRow @@ -386,7 +502,378 @@ const SCIP_Cutsel = Cvoid const SCIP_CUTSEL = SCIP_Cutsel -const SCIP_Row = Cvoid +struct SCIP_RowSolVals + data::NTuple{24, UInt8} +end + +function Base.getproperty(x::Ptr{SCIP_RowSolVals}, f::Symbol) + f === :dualsol && return Ptr{Cdouble}(x + 0) + f === :activity && return Ptr{Cdouble}(x + 8) + f === :basisstatus && return (Ptr{Cuint}(x + 16), 0, 2) + return getfield(x, f) +end + +function Base.getproperty(x::SCIP_RowSolVals, f::Symbol) + r = Ref{SCIP_RowSolVals}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_RowSolVals}, r) + fptr = getproperty(ptr, f) + begin + if fptr isa Ptr + return GC.@preserve(r, unsafe_load(fptr)) + else + (baseptr, offset, width) = fptr + ty = eltype(baseptr) + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = GC.@preserve(r, unsafe_load(baseptr32)) + if offset + width > 32 + u64 |= GC.@preserve(r, unsafe_load(baseptr32 + 4)) << 32 + end + u64 = u64 >> offset & (1 << width - 1) + return u64 % ty + end + end +end + +function Base.setproperty!(x::Ptr{SCIP_RowSolVals}, f::Symbol, v) + fptr = getproperty(x, f) + if fptr isa Ptr + unsafe_store!(getproperty(x, f), v) + else + (baseptr, offset, width) = fptr + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = unsafe_load(baseptr32) + straddle = offset + width > 32 + if straddle + u64 |= unsafe_load(baseptr32 + 4) << 32 + end + mask = 1 << width - 1 + u64 &= ~(mask << offset) + u64 |= (unsigned(v) & mask) << offset + unsafe_store!(baseptr32, u64 & typemax(UInt32)) + if straddle + unsafe_store!(baseptr32 + 4, u64 >> 32) + end + end +end + +function Base.propertynames(x::SCIP_RowSolVals, private::Bool = false) + (:dualsol, :activity, :basisstatus, if private + fieldnames(typeof(x)) + else + () + end...) +end + +const SCIP_ROWSOLVALS = SCIP_RowSolVals + +struct SCIP_ColSolVals + data::NTuple{24, UInt8} +end + +function Base.getproperty(x::Ptr{SCIP_ColSolVals}, f::Symbol) + f === :primsol && return Ptr{Cdouble}(x + 0) + f === :redcost && return Ptr{Cdouble}(x + 8) + f === :basisstatus && return (Ptr{Cuint}(x + 16), 0, 2) + return getfield(x, f) +end + +function Base.getproperty(x::SCIP_ColSolVals, f::Symbol) + r = Ref{SCIP_ColSolVals}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_ColSolVals}, r) + fptr = getproperty(ptr, f) + begin + if fptr isa Ptr + return GC.@preserve(r, unsafe_load(fptr)) + else + (baseptr, offset, width) = fptr + ty = eltype(baseptr) + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = GC.@preserve(r, unsafe_load(baseptr32)) + if offset + width > 32 + u64 |= GC.@preserve(r, unsafe_load(baseptr32 + 4)) << 32 + end + u64 = u64 >> offset & (1 << width - 1) + return u64 % ty + end + end +end + +function Base.setproperty!(x::Ptr{SCIP_ColSolVals}, f::Symbol, v) + fptr = getproperty(x, f) + if fptr isa Ptr + unsafe_store!(getproperty(x, f), v) + else + (baseptr, offset, width) = fptr + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = unsafe_load(baseptr32) + straddle = offset + width > 32 + if straddle + u64 |= unsafe_load(baseptr32 + 4) << 32 + end + mask = 1 << width - 1 + u64 &= ~(mask << offset) + u64 |= (unsigned(v) & mask) << offset + unsafe_store!(baseptr32, u64 & typemax(UInt32)) + if straddle + unsafe_store!(baseptr32 + 4, u64 >> 32) + end + end +end + +function Base.propertynames(x::SCIP_ColSolVals, private::Bool = false) + (:primsol, :redcost, :basisstatus, if private + fieldnames(typeof(x)) + else + () + end...) +end + +const SCIP_COLSOLVALS = SCIP_ColSolVals + +struct SCIP_Col + data::NTuple{280, UInt8} +end + +function Base.getproperty(x::Ptr{SCIP_Col}, f::Symbol) + f === :obj && return Ptr{Cdouble}(x + 0) + f === :lb && return Ptr{Cdouble}(x + 8) + f === :ub && return Ptr{Cdouble}(x + 16) + f === :unchangedobj && return Ptr{Cdouble}(x + 24) + f === :lazylb && return Ptr{Cdouble}(x + 32) + f === :lazyub && return Ptr{Cdouble}(x + 40) + f === :flushedobj && return Ptr{Cdouble}(x + 48) + f === :flushedlb && return Ptr{Cdouble}(x + 56) + f === :flushedub && return Ptr{Cdouble}(x + 64) + f === :primsol && return Ptr{Cdouble}(x + 72) + f === :redcost && return Ptr{Cdouble}(x + 80) + f === :farkascoef && return Ptr{Cdouble}(x + 88) + f === :minprimsol && return Ptr{Cdouble}(x + 96) + f === :maxprimsol && return Ptr{Cdouble}(x + 104) + f === :sbdown && return Ptr{Cdouble}(x + 112) + f === :sbup && return Ptr{Cdouble}(x + 120) + f === :sbsolval && return Ptr{Cdouble}(x + 128) + f === :sblpobjval && return Ptr{Cdouble}(x + 136) + f === :sbnode && return Ptr{Clonglong}(x + 144) + f === :obsoletenode && return Ptr{Clonglong}(x + 152) + f === :storedsolvals && return Ptr{Ptr{SCIP_COLSOLVALS}}(x + 160) + f === :var && return Ptr{Ptr{SCIP_VAR}}(x + 168) + f === :rows && return Ptr{Ptr{Ptr{SCIP_ROW}}}(x + 176) + f === :vals && return Ptr{Ptr{Cdouble}}(x + 184) + f === :validredcostlp && return Ptr{Clonglong}(x + 192) + f === :validfarkaslp && return Ptr{Clonglong}(x + 200) + f === :validsblp && return Ptr{Clonglong}(x + 208) + f === :linkpos && return Ptr{Ptr{Cint}}(x + 216) + f === :index && return Ptr{Cint}(x + 224) + f === :size && return Ptr{Cint}(x + 228) + f === :len && return Ptr{Cint}(x + 232) + f === :nlprows && return Ptr{Cint}(x + 236) + f === :nunlinked && return Ptr{Cint}(x + 240) + f === :lppos && return Ptr{Cint}(x + 244) + f === :lpipos && return Ptr{Cint}(x + 248) + f === :lpdepth && return Ptr{Cint}(x + 252) + f === :sbitlim && return Ptr{Cint}(x + 256) + f === :nsbcalls && return Ptr{Cint}(x + 260) + f === :age && return Ptr{Cint}(x + 264) + f === :var_probindex && return Ptr{Cint}(x + 268) + f === :basisstatus && return (Ptr{Cuint}(x + 272), 0, 2) + f === :lprowssorted && return (Ptr{Cuint}(x + 272), 2, 1) + f === :nonlprowssorted && return (Ptr{Cuint}(x + 272), 3, 1) + f === :objchanged && return (Ptr{Cuint}(x + 272), 4, 1) + f === :lbchanged && return (Ptr{Cuint}(x + 272), 5, 1) + f === :ubchanged && return (Ptr{Cuint}(x + 272), 6, 1) + f === :coefchanged && return (Ptr{Cuint}(x + 272), 7, 1) + f === :integral && return (Ptr{Cuint}(x + 272), 8, 1) + f === :impliedintegral && return (Ptr{Cuint}(x + 272), 9, 1) + f === :removable && return (Ptr{Cuint}(x + 272), 10, 1) + f === :sbdownvalid && return (Ptr{Cuint}(x + 272), 11, 1) + f === :sbupvalid && return (Ptr{Cuint}(x + 272), 12, 1) + return getfield(x, f) +end + +function Base.getproperty(x::SCIP_Col, f::Symbol) + r = Ref{SCIP_Col}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_Col}, r) + fptr = getproperty(ptr, f) + begin + if fptr isa Ptr + return GC.@preserve(r, unsafe_load(fptr)) + else + (baseptr, offset, width) = fptr + ty = eltype(baseptr) + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = GC.@preserve(r, unsafe_load(baseptr32)) + if offset + width > 32 + u64 |= GC.@preserve(r, unsafe_load(baseptr32 + 4)) << 32 + end + u64 = u64 >> offset & (1 << width - 1) + return u64 % ty + end + end +end + +function Base.setproperty!(x::Ptr{SCIP_Col}, f::Symbol, v) + fptr = getproperty(x, f) + if fptr isa Ptr + unsafe_store!(getproperty(x, f), v) + else + (baseptr, offset, width) = fptr + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = unsafe_load(baseptr32) + straddle = offset + width > 32 + if straddle + u64 |= unsafe_load(baseptr32 + 4) << 32 + end + mask = 1 << width - 1 + u64 &= ~(mask << offset) + u64 |= (unsigned(v) & mask) << offset + unsafe_store!(baseptr32, u64 & typemax(UInt32)) + if straddle + unsafe_store!(baseptr32 + 4, u64 >> 32) + end + end +end + +function Base.propertynames(x::SCIP_Col, private::Bool = false) + (:obj, :lb, :ub, :unchangedobj, :lazylb, :lazyub, :flushedobj, :flushedlb, :flushedub, :primsol, :redcost, :farkascoef, :minprimsol, :maxprimsol, :sbdown, :sbup, :sbsolval, :sblpobjval, :sbnode, :obsoletenode, :storedsolvals, :var, :rows, :vals, :validredcostlp, :validfarkaslp, :validsblp, :linkpos, :index, :size, :len, :nlprows, :nunlinked, :lppos, :lpipos, :lpdepth, :sbitlim, :nsbcalls, :age, :var_probindex, :basisstatus, :lprowssorted, :nonlprowssorted, :objchanged, :lbchanged, :ubchanged, :coefchanged, :integral, :impliedintegral, :removable, :sbdownvalid, :sbupvalid, if private + fieldnames(typeof(x)) + else + () + end...) +end + +const SCIP_COL = SCIP_Col + +const SCIP_EventFilter = Cvoid + +const SCIP_EVENTFILTER = SCIP_EventFilter + +const SCIP_RowExact = Cvoid + +const SCIP_ROWEXACT = SCIP_RowExact + +struct SCIP_Row + data::NTuple{320, UInt8} +end + +function Base.getproperty(x::Ptr{SCIP_Row}, f::Symbol) + f === :constant && return Ptr{Cdouble}(x + 0) + f === :lhs && return Ptr{Cdouble}(x + 8) + f === :rhs && return Ptr{Cdouble}(x + 16) + f === :flushedlhs && return Ptr{Cdouble}(x + 24) + f === :flushedrhs && return Ptr{Cdouble}(x + 32) + f === :sqrnorm && return Ptr{Cdouble}(x + 40) + f === :sumnorm && return Ptr{Cdouble}(x + 48) + f === :objprod && return Ptr{Cdouble}(x + 56) + f === :maxval && return Ptr{Cdouble}(x + 64) + f === :minval && return Ptr{Cdouble}(x + 72) + f === :dualsol && return Ptr{Cdouble}(x + 80) + f === :activity && return Ptr{Cdouble}(x + 88) + f === :dualfarkas && return Ptr{Cdouble}(x + 96) + f === :pseudoactivity && return Ptr{Cdouble}(x + 104) + f === :minactivity && return Ptr{Cdouble}(x + 112) + f === :maxactivity && return Ptr{Cdouble}(x + 120) + f === :validpsactivitydomchg && return Ptr{Clonglong}(x + 128) + f === :validactivitybdsdomchg && return Ptr{Clonglong}(x + 136) + f === :obsoletenode && return Ptr{Clonglong}(x + 144) + f === :activeinlpcounter && return Ptr{Clonglong}(x + 152) + f === :nlpsaftercreation && return Ptr{Clonglong}(x + 160) + f === :storedsolvals && return Ptr{Ptr{SCIP_ROWSOLVALS}}(x + 168) + f === :origin && return Ptr{Ptr{Cvoid}}(x + 176) + f === :name && return Ptr{Ptr{Cchar}}(x + 184) + f === :cols && return Ptr{Ptr{Ptr{SCIP_COL}}}(x + 192) + f === :cols_index && return Ptr{Ptr{Cint}}(x + 200) + f === :vals && return Ptr{Ptr{Cdouble}}(x + 208) + f === :linkpos && return Ptr{Ptr{Cint}}(x + 216) + f === :eventfilter && return Ptr{Ptr{SCIP_EVENTFILTER}}(x + 224) + f === :rowexact && return Ptr{Ptr{SCIP_ROWEXACT}}(x + 232) + f === :validactivitylp && return Ptr{Clonglong}(x + 240) + f === :index && return Ptr{Cint}(x + 248) + f === :size && return Ptr{Cint}(x + 252) + f === :len && return Ptr{Cint}(x + 256) + f === :nlpcols && return Ptr{Cint}(x + 260) + f === :nunlinked && return Ptr{Cint}(x + 264) + f === :nuses && return Ptr{Cint}(x + 268) + f === :lppos && return Ptr{Cint}(x + 272) + f === :lpipos && return Ptr{Cint}(x + 276) + f === :lpdepth && return Ptr{Cint}(x + 280) + f === :minidx && return Ptr{Cint}(x + 284) + f === :maxidx && return Ptr{Cint}(x + 288) + f === :numintcols && return Ptr{Cint}(x + 292) + f === :numimplintcols && return Ptr{Cint}(x + 296) + f === :nummaxval && return Ptr{Cint}(x + 300) + f === :numminval && return Ptr{Cint}(x + 304) + f === :age && return Ptr{Cint}(x + 308) + f === :rank && return Ptr{Cint}(x + 312) + f === :fromcutpool && return (Ptr{Cuint}(x + 316), 0, 1) + f === :basisstatus && return (Ptr{Cuint}(x + 316), 1, 2) + f === :lpcolssorted && return (Ptr{Cuint}(x + 316), 3, 1) + f === :nonlpcolssorted && return (Ptr{Cuint}(x + 316), 4, 1) + f === :delaysort && return (Ptr{Cuint}(x + 316), 5, 1) + f === :validminmaxidx && return (Ptr{Cuint}(x + 316), 6, 1) + f === :lhschanged && return (Ptr{Cuint}(x + 316), 7, 1) + f === :rhschanged && return (Ptr{Cuint}(x + 316), 8, 1) + f === :coefchanged && return (Ptr{Cuint}(x + 316), 9, 1) + f === :integral && return (Ptr{Cuint}(x + 316), 10, 1) + f === :_local && return (Ptr{Cuint}(x + 316), 11, 1) + f === :modifiable && return (Ptr{Cuint}(x + 316), 12, 1) + f === :removable && return (Ptr{Cuint}(x + 316), 13, 1) + f === :inglobalcutpool && return (Ptr{Cuint}(x + 316), 14, 1) + f === :normunreliable && return (Ptr{Cuint}(x + 316), 15, 1) + f === :nlocks && return (Ptr{Cuint}(x + 316), 16, 13) + f === :origintype && return (Ptr{Cuint}(x + 316), 29, 3) + return getfield(x, f) +end + +function Base.getproperty(x::SCIP_Row, f::Symbol) + r = Ref{SCIP_Row}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_Row}, r) + fptr = getproperty(ptr, f) + begin + if fptr isa Ptr + return GC.@preserve(r, unsafe_load(fptr)) + else + (baseptr, offset, width) = fptr + ty = eltype(baseptr) + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = GC.@preserve(r, unsafe_load(baseptr32)) + if offset + width > 32 + u64 |= GC.@preserve(r, unsafe_load(baseptr32 + 4)) << 32 + end + u64 = u64 >> offset & (1 << width - 1) + return u64 % ty + end + end +end + +function Base.setproperty!(x::Ptr{SCIP_Row}, f::Symbol, v) + fptr = getproperty(x, f) + if fptr isa Ptr + unsafe_store!(getproperty(x, f), v) + else + (baseptr, offset, width) = fptr + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = unsafe_load(baseptr32) + straddle = offset + width > 32 + if straddle + u64 |= unsafe_load(baseptr32 + 4) << 32 + end + mask = 1 << width - 1 + u64 &= ~(mask << offset) + u64 |= (unsigned(v) & mask) << offset + unsafe_store!(baseptr32, u64 & typemax(UInt32)) + if straddle + unsafe_store!(baseptr32 + 4, u64 >> 32) + end + end +end + +function Base.propertynames(x::SCIP_Row, private::Bool = false) + (:constant, :lhs, :rhs, :flushedlhs, :flushedrhs, :sqrnorm, :sumnorm, :objprod, :maxval, :minval, :dualsol, :activity, :dualfarkas, :pseudoactivity, :minactivity, :maxactivity, :validpsactivitydomchg, :validactivitybdsdomchg, :obsoletenode, :activeinlpcounter, :nlpsaftercreation, :storedsolvals, :origin, :name, :cols, :cols_index, :vals, :linkpos, :eventfilter, :rowexact, :validactivitylp, :index, :size, :len, :nlpcols, :nunlinked, :nuses, :lppos, :lpipos, :lpdepth, :minidx, :maxidx, :numintcols, :numimplintcols, :nummaxval, :numminval, :age, :rank, :fromcutpool, :basisstatus, :lpcolssorted, :nonlpcolssorted, :delaysort, :validminmaxidx, :lhschanged, :rhschanged, :coefchanged, :integral, :_local, :modifiable, :removable, :inglobalcutpool, :normunreliable, :nlocks, :origintype, if private + fieldnames(typeof(x)) + else + () + end...) +end const SCIP_ROW = SCIP_Row @@ -394,6 +881,24 @@ const SCIP_CutselData = Cvoid const SCIP_CUTSELDATA = SCIP_CutselData +@enum SCIP_Datatree_Valuetype::UInt32 begin + SCIP_DATATREE_BOOL = 0 + SCIP_DATATREE_LONG = 1 + SCIP_DATATREE_REAL = 2 + SCIP_DATATREE_STRING = 3 + SCIP_DATATREE_BOOLARRAY = 4 + SCIP_DATATREE_LONGARRAY = 5 + SCIP_DATATREE_REALARRAY = 6 + SCIP_DATATREE_STRINGARRAY = 7 + SCIP_DATATREE_DATATREE = 8 +end + +const SCIP_DATATREE_VALUETYPE = SCIP_Datatree_Valuetype + +const SCIP_Datatree = Cvoid + +const SCIP_DATATREE = SCIP_Datatree + const SCIP_Decomp = Cvoid const SCIP_DECOMP = SCIP_Decomp @@ -496,6 +1001,10 @@ const SCIP_EventTypeChg = Cvoid const SCIP_EVENTTYPECHG = SCIP_EventTypeChg +const SCIP_EventImplTypeChg = Cvoid + +const SCIP_EVENTTYPEIMPLCHG = SCIP_EventImplTypeChg + const SCIP_EventRowAddedSepa = Cvoid const SCIP_EVENTROWADDEDSEPA = SCIP_EventRowAddedSepa @@ -524,10 +1033,6 @@ const SCIP_EventRowSideChanged = Cvoid const SCIP_EVENTROWSIDECHANGED = SCIP_EventRowSideChanged -const SCIP_EventFilter = Cvoid - -const SCIP_EVENTFILTER = SCIP_EventFilter - const SCIP_EventQueue = Cvoid const SCIP_EVENTQUEUE = SCIP_EventQueue @@ -575,6 +1080,18 @@ end SCIP_MONOTONE_CONST = 3 end +@enum SCIP_ImplintType::UInt32 begin + SCIP_IMPLINTTYPE_NONE = 0 + SCIP_IMPLINTTYPE_WEAK = 1 + SCIP_IMPLINTTYPE_STRONG = 2 +end + +const SCIP_IMPLINTTYPE = SCIP_ImplintType + +const SYM_ExprData = Cvoid + +const SYM_EXPRDATA = SYM_ExprData + const SCIP_ROUNDMODE = Cint function SCIPintervalHasRoundingControl() @@ -582,12 +1099,7 @@ function SCIPintervalHasRoundingControl() end function SCIPintervalSetRoundingMode(roundmode) - ccall( - (:SCIPintervalSetRoundingMode, libscip), - Cvoid, - (SCIP_ROUNDMODE,), - roundmode, - ) + ccall((:SCIPintervalSetRoundingMode, libscip), Cvoid, (SCIP_ROUNDMODE,), roundmode) end function SCIPintervalGetRoundingMode() @@ -623,894 +1135,269 @@ function SCIPintervalGetSup(interval) end function SCIPintervalSet(resultant, value) - ccall( - (:SCIPintervalSet, libscip), - Cvoid, - (Ptr{SCIP_INTERVAL}, Cdouble), - resultant, - value, - ) + ccall((:SCIPintervalSet, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble), resultant, value) +end + +function SCIPintervalSetRational(resultant, value) + ccall((:SCIPintervalSetRational, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Ptr{SCIP_RATIONAL}), resultant, value) end function SCIPintervalSetBounds(resultant, inf, sup) - ccall( - (:SCIPintervalSetBounds, libscip), - Cvoid, - (Ptr{SCIP_INTERVAL}, Cdouble, Cdouble), - resultant, - inf, - sup, - ) + ccall((:SCIPintervalSetBounds, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble, Cdouble), resultant, inf, sup) end function SCIPintervalSetEmpty(resultant) - ccall( - (:SCIPintervalSetEmpty, libscip), - Cvoid, - (Ptr{SCIP_INTERVAL},), - resultant, - ) + ccall((:SCIPintervalSetEmpty, libscip), Cvoid, (Ptr{SCIP_INTERVAL},), resultant) end function SCIPintervalIsEmpty(infinity, operand) - ccall( - (:SCIPintervalIsEmpty, libscip), - Cuint, - (Cdouble, SCIP_INTERVAL), - infinity, - operand, - ) + ccall((:SCIPintervalIsEmpty, libscip), Cuint, (Cdouble, SCIP_INTERVAL), infinity, operand) end function SCIPintervalSetEntire(infinity, resultant) - ccall( - (:SCIPintervalSetEntire, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}), - infinity, - resultant, - ) + ccall((:SCIPintervalSetEntire, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}), infinity, resultant) end function SCIPintervalIsEntire(infinity, operand) - ccall( - (:SCIPintervalIsEntire, libscip), - Cuint, - (Cdouble, SCIP_INTERVAL), - infinity, - operand, - ) + ccall((:SCIPintervalIsEntire, libscip), Cuint, (Cdouble, SCIP_INTERVAL), infinity, operand) end function SCIPintervalIsPositiveInfinity(infinity, operand) - ccall( - (:SCIPintervalIsPositiveInfinity, libscip), - Cuint, - (Cdouble, SCIP_INTERVAL), - infinity, - operand, - ) + ccall((:SCIPintervalIsPositiveInfinity, libscip), Cuint, (Cdouble, SCIP_INTERVAL), infinity, operand) end function SCIPintervalIsNegativeInfinity(infinity, operand) - ccall( - (:SCIPintervalIsNegativeInfinity, libscip), - Cuint, - (Cdouble, SCIP_INTERVAL), - infinity, - operand, - ) + ccall((:SCIPintervalIsNegativeInfinity, libscip), Cuint, (Cdouble, SCIP_INTERVAL), infinity, operand) end function SCIPintervalIsSubsetEQ(infinity, operand1, operand2) - ccall( - (:SCIPintervalIsSubsetEQ, libscip), - Cuint, - (Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - operand1, - operand2, - ) + ccall((:SCIPintervalIsSubsetEQ, libscip), Cuint, (Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), infinity, operand1, operand2) end function SCIPintervalAreDisjoint(operand1, operand2) - ccall( - (:SCIPintervalAreDisjoint, libscip), - Cuint, - (SCIP_INTERVAL, SCIP_INTERVAL), - operand1, - operand2, - ) + ccall((:SCIPintervalAreDisjoint, libscip), Cuint, (SCIP_INTERVAL, SCIP_INTERVAL), operand1, operand2) end function SCIPintervalAreDisjointEps(eps, operand1, operand2) - ccall( - (:SCIPintervalAreDisjointEps, libscip), - Cuint, - (Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), - eps, - operand1, - operand2, - ) + ccall((:SCIPintervalAreDisjointEps, libscip), Cuint, (Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), eps, operand1, operand2) end function SCIPintervalIntersect(resultant, operand1, operand2) - ccall( - (:SCIPintervalIntersect, libscip), - Cvoid, - (Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalIntersect, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), resultant, operand1, operand2) end function SCIPintervalIntersectEps(resultant, eps, operand1, operand2) - ccall( - (:SCIPintervalIntersectEps, libscip), - Cvoid, - (Ptr{SCIP_INTERVAL}, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), - resultant, - eps, - operand1, - operand2, - ) + ccall((:SCIPintervalIntersectEps, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), resultant, eps, operand1, operand2) end function SCIPintervalUnify(resultant, operand1, operand2) - ccall( - (:SCIPintervalUnify, libscip), - Cvoid, - (Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalUnify, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), resultant, operand1, operand2) end function SCIPintervalAddInf(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalAddInf, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalAddInf, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalAddSup(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalAddSup, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalAddSup, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalAdd(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalAdd, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalAdd, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalAddScalar(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalAddScalar, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalAddScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) end function SCIPintervalAddVectors(infinity, resultant, length, operand1, operand2) - ccall( - (:SCIPintervalAddVectors, libscip), - Cvoid, - ( - Cdouble, - Ptr{SCIP_INTERVAL}, - Cint, - Ptr{SCIP_INTERVAL}, - Ptr{SCIP_INTERVAL}, - ), - infinity, - resultant, - length, - operand1, - operand2, - ) + ccall((:SCIPintervalAddVectors, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{SCIP_INTERVAL}), infinity, resultant, length, operand1, operand2) end function SCIPintervalSub(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalSub, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalSub, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalSubScalar(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalSubScalar, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalSubScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) end function SCIPintervalMulInf(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalMulInf, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalMulInf, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalMulSup(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalMulSup, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalMulSup, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalMul(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalMul, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalMul, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalMulScalarInf(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalMulScalarInf, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalMulScalarInf, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) end function SCIPintervalMulScalarSup(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalMulScalarSup, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalMulScalarSup, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) end function SCIPintervalMulScalar(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalMulScalar, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalMulScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) end function SCIPintervalDiv(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalDiv, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalDiv, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalDivScalar(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalDivScalar, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalDivScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) end function SCIPintervalScalprod(infinity, resultant, length, operand1, operand2) - ccall( - (:SCIPintervalScalprod, libscip), - Cvoid, - ( - Cdouble, - Ptr{SCIP_INTERVAL}, - Cint, - Ptr{SCIP_INTERVAL}, - Ptr{SCIP_INTERVAL}, - ), - infinity, - resultant, - length, - operand1, - operand2, - ) -end - -function SCIPintervalScalprodScalarsInf( - infinity, - resultant, - length, - operand1, - operand2, -) - ccall( - (:SCIPintervalScalprodScalarsInf, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), - infinity, - resultant, - length, - operand1, - operand2, - ) -end - -function SCIPintervalScalprodScalarsSup( - infinity, - resultant, - length, - operand1, - operand2, -) - ccall( - (:SCIPintervalScalprodScalarsSup, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), - infinity, - resultant, - length, - operand1, - operand2, - ) -end - -function SCIPintervalScalprodScalars( - infinity, - resultant, - length, - operand1, - operand2, -) - ccall( - (:SCIPintervalScalprodScalars, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), - infinity, - resultant, - length, - operand1, - operand2, - ) + ccall((:SCIPintervalScalprod, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{SCIP_INTERVAL}), infinity, resultant, length, operand1, operand2) +end + +function SCIPintervalScalprodScalarsInf(infinity, resultant, length, operand1, operand2) + ccall((:SCIPintervalScalprodScalarsInf, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), infinity, resultant, length, operand1, operand2) +end + +function SCIPintervalScalprodScalarsSup(infinity, resultant, length, operand1, operand2) + ccall((:SCIPintervalScalprodScalarsSup, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), infinity, resultant, length, operand1, operand2) +end + +function SCIPintervalScalprodScalars(infinity, resultant, length, operand1, operand2) + ccall((:SCIPintervalScalprodScalars, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), infinity, resultant, length, operand1, operand2) end function SCIPintervalSquare(infinity, resultant, operand) - ccall( - (:SCIPintervalSquare, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalSquare, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalSquareRoot(infinity, resultant, operand) - ccall( - (:SCIPintervalSquareRoot, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalSquareRoot, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalPower(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalPower, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalPower, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalPowerScalar(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalPowerScalar, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalPowerScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) end function SCIPintervalPowerScalarScalar(resultant, operand1, operand2) - ccall( - (:SCIPintervalPowerScalarScalar, libscip), - Cvoid, - (Ptr{SCIP_INTERVAL}, Cdouble, Cdouble), - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalPowerScalarScalar, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble, Cdouble), resultant, operand1, operand2) end function SCIPintervalPowerScalarIntegerInf(operand1, operand2) - ccall( - (:SCIPintervalPowerScalarIntegerInf, libscip), - Cdouble, - (Cdouble, Cint), - operand1, - operand2, - ) + ccall((:SCIPintervalPowerScalarIntegerInf, libscip), Cdouble, (Cdouble, Cint), operand1, operand2) end function SCIPintervalPowerScalarIntegerSup(operand1, operand2) - ccall( - (:SCIPintervalPowerScalarIntegerSup, libscip), - Cdouble, - (Cdouble, Cint), - operand1, - operand2, - ) + ccall((:SCIPintervalPowerScalarIntegerSup, libscip), Cdouble, (Cdouble, Cint), operand1, operand2) end function SCIPintervalPowerScalarInteger(resultant, operand1, operand2) - ccall( - (:SCIPintervalPowerScalarInteger, libscip), - Cvoid, - (Ptr{SCIP_INTERVAL}, Cdouble, Cint), - resultant, - operand1, - operand2, - ) -end - -function SCIPintervalPowerScalarInverse( - infinity, - resultant, - basedomain, - exponent, - image, -) - ccall( - (:SCIPintervalPowerScalarInverse, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble, SCIP_INTERVAL), - infinity, - resultant, - basedomain, - exponent, - image, - ) + ccall((:SCIPintervalPowerScalarInteger, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble, Cint), resultant, operand1, operand2) +end + +function SCIPintervalPowerScalarInverse(infinity, resultant, basedomain, exponent, image) + ccall((:SCIPintervalPowerScalarInverse, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble, SCIP_INTERVAL), infinity, resultant, basedomain, exponent, image) end function SCIPintervalSignPowerScalar(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalSignPowerScalar, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalSignPowerScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) end function SCIPintervalReciprocal(infinity, resultant, operand) - ccall( - (:SCIPintervalReciprocal, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalReciprocal, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalExp(infinity, resultant, operand) - ccall( - (:SCIPintervalExp, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalExp, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalLog(infinity, resultant, operand) - ccall( - (:SCIPintervalLog, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalLog, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalMin(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalMin, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalMin, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) end function SCIPintervalMax(infinity, resultant, operand1, operand2) - ccall( - (:SCIPintervalMax, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - operand1, - operand2, - ) + ccall((:SCIPintervalMax, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) +end + +function SCIPintervalAbsMax(interval) + ccall((:SCIPintervalAbsMax, libscip), Cdouble, (SCIP_INTERVAL,), interval) end function SCIPintervalAbs(infinity, resultant, operand) - ccall( - (:SCIPintervalAbs, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalAbs, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalSin(infinity, resultant, operand) - ccall( - (:SCIPintervalSin, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalSin, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalCos(infinity, resultant, operand) - ccall( - (:SCIPintervalCos, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalCos, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalSign(infinity, resultant, operand) - ccall( - (:SCIPintervalSign, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalSign, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalEntropy(infinity, resultant, operand) - ccall( - (:SCIPintervalEntropy, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), - infinity, - resultant, - operand, - ) + ccall((:SCIPintervalEntropy, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) end function SCIPintervalQuadUpperBound(infinity, a, b_, x) - ccall( - (:SCIPintervalQuadUpperBound, libscip), - Cdouble, - (Cdouble, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - a, - b_, - x, - ) + ccall((:SCIPintervalQuadUpperBound, libscip), Cdouble, (Cdouble, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), infinity, a, b_, x) end function SCIPintervalQuad(infinity, resultant, sqrcoeff, lincoeff, xrng) - ccall( - (:SCIPintervalQuad, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), - infinity, - resultant, - sqrcoeff, - lincoeff, - xrng, - ) -end - -function SCIPintervalSolveUnivariateQuadExpressionPositive( - infinity, - resultant, - sqrcoeff, - lincoeff, - rhs, - xbnds, -) - ccall( - (:SCIPintervalSolveUnivariateQuadExpressionPositive, libscip), - Cvoid, - ( - Cdouble, - Ptr{SCIP_INTERVAL}, - SCIP_INTERVAL, - SCIP_INTERVAL, - SCIP_INTERVAL, - SCIP_INTERVAL, - ), - infinity, - resultant, - sqrcoeff, - lincoeff, - rhs, - xbnds, - ) -end - -function SCIPintervalSolveUnivariateQuadExpressionNegative( - infinity, - resultant, - sqrcoeff, - lincoeff, - rhs, - xbnds, -) - ccall( - (:SCIPintervalSolveUnivariateQuadExpressionNegative, libscip), - Cvoid, - ( - Cdouble, - Ptr{SCIP_INTERVAL}, - SCIP_INTERVAL, - SCIP_INTERVAL, - SCIP_INTERVAL, - SCIP_INTERVAL, - ), - infinity, - resultant, - sqrcoeff, - lincoeff, - rhs, - xbnds, - ) -end - -function SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar( - infinity, - resultant, - sqrcoeff, - lincoeff, - rhs, - xbnds, -) - ccall( - (:SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar, libscip), - Cvoid, - (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Cdouble, SCIP_INTERVAL), - infinity, - resultant, - sqrcoeff, - lincoeff, - rhs, - xbnds, - ) -end - -function SCIPintervalSolveUnivariateQuadExpression( - infinity, - resultant, - sqrcoeff, - lincoeff, - rhs, - xbnds, -) - ccall( - (:SCIPintervalSolveUnivariateQuadExpression, libscip), - Cvoid, - ( - Cdouble, - Ptr{SCIP_INTERVAL}, - SCIP_INTERVAL, - SCIP_INTERVAL, - SCIP_INTERVAL, - SCIP_INTERVAL, - ), - infinity, - resultant, - sqrcoeff, - lincoeff, - rhs, - xbnds, - ) -end - -function SCIPintervalQuadBivar( - infinity, - resultant, - ax, - ay, - axy, - bx, - by, - xbnds, - ybnds, -) - ccall( - (:SCIPintervalQuadBivar, libscip), - Cvoid, - ( - Cdouble, - Ptr{SCIP_INTERVAL}, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - SCIP_INTERVAL, - SCIP_INTERVAL, - ), - infinity, - resultant, - ax, - ay, - axy, - bx, - by, - xbnds, - ybnds, - ) -end - -function SCIPintervalSolveBivariateQuadExpressionAllScalar( - infinity, - resultant, - ax, - ay, - axy, - bx, - by, - rhs, - xbnds, - ybnds, -) - ccall( - (:SCIPintervalSolveBivariateQuadExpressionAllScalar, libscip), - Cvoid, - ( - Cdouble, - Ptr{SCIP_INTERVAL}, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - SCIP_INTERVAL, - SCIP_INTERVAL, - SCIP_INTERVAL, - ), - infinity, - resultant, - ax, - ay, - axy, - bx, - by, - rhs, - xbnds, - ybnds, - ) -end - -function SCIPintervalPropagateWeightedSum( - infinity, - noperands, - operands, - weights, - constant, - rhs, - resultants, - infeasible, -) - ccall( - (:SCIPintervalPropagateWeightedSum, libscip), - Cint, - ( - Cdouble, - Cint, - Ptr{SCIP_INTERVAL}, - Ptr{Cdouble}, - Cdouble, - SCIP_INTERVAL, - Ptr{SCIP_INTERVAL}, - Ptr{Cuint}, - ), - infinity, - noperands, - operands, - weights, - constant, - rhs, - resultants, - infeasible, - ) + ccall((:SCIPintervalQuad, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, xrng) +end + +function SCIPintervalSolveUnivariateQuadExpressionPositive(infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) + ccall((:SCIPintervalSolveUnivariateQuadExpressionPositive, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) +end + +function SCIPintervalSolveUnivariateQuadExpressionNegative(infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) + ccall((:SCIPintervalSolveUnivariateQuadExpressionNegative, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) +end + +function SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar(infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) + ccall((:SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Cdouble, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) +end + +function SCIPintervalSolveUnivariateQuadExpression(infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) + ccall((:SCIPintervalSolveUnivariateQuadExpression, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) +end + +function SCIPintervalQuadBivar(infinity, resultant, ax, ay, axy, bx, by, xbnds, ybnds) + ccall((:SCIPintervalQuadBivar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, ax, ay, axy, bx, by, xbnds, ybnds) +end + +function SCIPintervalSolveBivariateQuadExpressionAllScalar(infinity, resultant, ax, ay, axy, bx, by, rhs, xbnds, ybnds) + ccall((:SCIPintervalSolveBivariateQuadExpressionAllScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, ax, ay, axy, bx, by, rhs, xbnds, ybnds) +end + +function SCIPintervalPropagateWeightedSum(infinity, noperands, operands, weights, constant, rhs, resultants, infeasible) + ccall((:SCIPintervalPropagateWeightedSum, libscip), Cint, (Cdouble, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}, Cdouble, SCIP_INTERVAL, Ptr{SCIP_INTERVAL}, Ptr{Cuint}), infinity, noperands, operands, weights, constant, rhs, resultants, infeasible) end struct SCIP_EXPRITER_USERDATA - data::NTuple{8,UInt8} + data::NTuple{8, UInt8} end function Base.getproperty(x::Ptr{SCIP_EXPRITER_USERDATA}, f::Symbol) f === :realval && return Ptr{Cdouble}(x + 0) f === :intval && return Ptr{Cint}(x + 0) - f === :intvals && return Ptr{NTuple{2,Cint}}(x + 0) + f === :intvals && return Ptr{NTuple{2, Cint}}(x + 0) f === :uintval && return Ptr{Cuint}(x + 0) f === :ptrval && return Ptr{Ptr{Cvoid}}(x + 0) return getfield(x, f) @@ -1527,6 +1414,14 @@ function Base.setproperty!(x::Ptr{SCIP_EXPRITER_USERDATA}, f::Symbol, v) unsafe_store!(getproperty(x, f), v) end +function Base.propertynames(x::SCIP_EXPRITER_USERDATA, private::Bool = false) + (:realval, :intval, :intvals, :uintval, :ptrval, if private + fieldnames(typeof(x)) + else + () + end...) +end + @enum SCIP_EXPRITER_TYPE::UInt32 begin SCIP_EXPRITER_RTOPOLOGIC = 0 SCIP_EXPRITER_BFS = 1 @@ -1569,6 +1464,7 @@ const SCIP_DIVETYPE = Cuint SCIP_DIVECONTEXT_TOTAL = 0 SCIP_DIVECONTEXT_SINGLE = 1 SCIP_DIVECONTEXT_ADAPTIVE = 2 + SCIP_DIVECONTEXT_SCHEDULER = 3 end const SCIP_DIVECONTEXT = SCIP_DiveContext @@ -1598,6 +1494,119 @@ const SCIP_ValueHistory = Cvoid const SCIP_VALUEHISTORY = SCIP_ValueHistory +const SCIP_Hypergraph = Cvoid + +const SCIP_HYPERGRAPH = SCIP_Hypergraph + +const SCIP_HYPERGRAPH_OVERLAP = Cint + +const SCIP_Hypergraph_OverlapData = Cvoid + +const SCIP_HYPERGRAPH_OVERLAPDATA = SCIP_Hypergraph_OverlapData + +const SCIP_HYPERGRAPH_EDGE = Cint + +const SCIP_HYPERGRAPH_VERTEX = Cint + +struct SCIP_Hypergraph_Iter + data::NTuple{48, UInt8} +end + +function Base.getproperty(x::Ptr{SCIP_Hypergraph_Iter}, f::Symbol) + f === :base && return Ptr{SCIP_HYPERGRAPH_EDGE}(x + 0) + f === :vertexidx && return Ptr{Cint}(x + 4) + f === :minvertex && return Ptr{SCIP_HYPERGRAPH_VERTEX}(x + 8) + f === :edgeidx && return Ptr{Cint}(x + 12) + f === :adjacent && return Ptr{SCIP_HYPERGRAPH_EDGE}(x + 16) + f === :ncommonvertices && return Ptr{Cint}(x + 20) + f === :sizecommonvertices && return Ptr{Cint}(x + 24) + f === :commonvertices && return Ptr{Ptr{SCIP_HYPERGRAPH_VERTEX}}(x + 32) + f === :overlap && return Ptr{SCIP_HYPERGRAPH_OVERLAP}(x + 40) + f === :minoverlapsize && return (Ptr{Cuint}(x + 44), 0, 6) + f === :onlylater && return (Ptr{Cuint}(x + 44), 6, 1) + f === :findoverlaps && return (Ptr{Cuint}(x + 44), 7, 1) + return getfield(x, f) +end + +function Base.getproperty(x::SCIP_Hypergraph_Iter, f::Symbol) + r = Ref{SCIP_Hypergraph_Iter}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_Hypergraph_Iter}, r) + fptr = getproperty(ptr, f) + begin + if fptr isa Ptr + return GC.@preserve(r, unsafe_load(fptr)) + else + (baseptr, offset, width) = fptr + ty = eltype(baseptr) + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = GC.@preserve(r, unsafe_load(baseptr32)) + if offset + width > 32 + u64 |= GC.@preserve(r, unsafe_load(baseptr32 + 4)) << 32 + end + u64 = u64 >> offset & (1 << width - 1) + return u64 % ty + end + end +end + +function Base.setproperty!(x::Ptr{SCIP_Hypergraph_Iter}, f::Symbol, v) + fptr = getproperty(x, f) + if fptr isa Ptr + unsafe_store!(getproperty(x, f), v) + else + (baseptr, offset, width) = fptr + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = unsafe_load(baseptr32) + straddle = offset + width > 32 + if straddle + u64 |= unsafe_load(baseptr32 + 4) << 32 + end + mask = 1 << width - 1 + u64 &= ~(mask << offset) + u64 |= (unsigned(v) & mask) << offset + unsafe_store!(baseptr32, u64 & typemax(UInt32)) + if straddle + unsafe_store!(baseptr32 + 4, u64 >> 32) + end + end +end + +function Base.propertynames(x::SCIP_Hypergraph_Iter, private::Bool = false) + (:base, :vertexidx, :minvertex, :edgeidx, :adjacent, :ncommonvertices, :sizecommonvertices, :commonvertices, :overlap, :minoverlapsize, :onlylater, :findoverlaps, if private + fieldnames(typeof(x)) + else + () + end...) +end + +const SCIP_HYPERGRAPH_ITER = SCIP_Hypergraph_Iter + +const SCIP_Hypergraph_NodeData = Cvoid + +const SCIP_HYPERGRAPH_VERTEXDATA = SCIP_Hypergraph_NodeData + +const SCIP_Hypergraph_EdgeData = Cvoid + +const SCIP_HYPERGRAPH_EDGEDATA = SCIP_Hypergraph_EdgeData + +@enum SCIP_Hypergraph_IterCtrl::UInt32 begin + SCIP_HYPERGRAPH_ITERCTRL_MINOVERLAP = 255 + SCIP_HYPERGRAPH_ITERCTRL_ONLYLATER = 256 + SCIP_HYPERGRAPH_ITERCTRL_FINDOVERLAPS = 512 +end + +const SCIP_HYPERGRAPH_ITERCTRL = SCIP_Hypergraph_IterCtrl + +const SCIP_IISfinder = Cvoid + +const SCIP_IISFINDER = SCIP_IISfinder + +const SCIP_IIS = Cvoid + +const SCIP_IISfinderData = Cvoid + +const SCIP_IISFINDERDATA = SCIP_IISfinderData + const SCIP_VBounds = Cvoid const SCIP_VBOUNDS = SCIP_VBounds @@ -1661,26 +1670,208 @@ end const SCIP_LPALGO = SCIP_LPAlgo -const SCIP_ColSolVals = Cvoid +struct SCIP_LpSolVals + lpsolstat::SCIP_LPSOLSTAT + lpobjval::Cdouble + primalfeasible::Cuint + primalchecked::Cuint + dualfeasible::Cuint + dualchecked::Cuint + solisbasic::Cuint + lpissolved::Cuint + hasprovedboundexact::Cuint +end -const SCIP_COLSOLVALS = SCIP_ColSolVals +const SCIP_LPSOLVALS = SCIP_LpSolVals -const SCIP_RowSolVals = Cvoid +const SCIP_LPi = Cvoid -const SCIP_ROWSOLVALS = SCIP_RowSolVals +const SCIP_LPI = SCIP_LPi -const SCIP_LpSolVals = Cvoid +const SCIP_LpExact = Cvoid -const SCIP_LPSOLVALS = SCIP_LpSolVals +const SCIP_LPEXACT = SCIP_LpExact -const SCIP_Col = Cvoid +const SCIP_LPiState = Cvoid -const SCIP_COL = SCIP_Col +const SCIP_LPISTATE = SCIP_LPiState + +@enum SCIP_Pricing::UInt32 begin + 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 +end + +const SCIP_PRICING = SCIP_Pricing -const SCIP_Lp = Cvoid +struct SCIP_Lp + lpobjval::Cdouble + looseobjval::Cdouble + rellooseobjval::Cdouble + glbpseudoobjval::Cdouble + relglbpseudoobjval::Cdouble + pseudoobjval::Cdouble + relpseudoobjval::Cdouble + rootlpobjval::Cdouble + rootlooseobjval::Cdouble + cutoffbound::Cdouble + feastol::Cdouble + lpiobjlim::Cdouble + lpifeastol::Cdouble + lpidualfeastol::Cdouble + lpibarrierconvtol::Cdouble + lpiconditionlimit::Cdouble + lpimarkowitz::Cdouble + objsqrnorm::Cdouble + objsumnorm::Cdouble + degeneracy::Cdouble + varconsratio::Cdouble + lpi::Ptr{SCIP_LPI} + lpicols::Ptr{Ptr{SCIP_COL}} + lpirows::Ptr{Ptr{SCIP_ROW}} + chgcols::Ptr{Ptr{SCIP_COL}} + chgrows::Ptr{Ptr{SCIP_ROW}} + cols::Ptr{Ptr{SCIP_COL}} + lazycols::Ptr{Ptr{SCIP_COL}} + rows::Ptr{Ptr{SCIP_ROW}} + lpexact::Ptr{SCIP_LPEXACT} + soldirection::Ptr{Cdouble} + divelpistate::Ptr{SCIP_LPISTATE} + divechgsides::Ptr{Cdouble} + divechgsidetypes::Ptr{SCIP_SIDETYPE} + divechgrows::Ptr{Ptr{SCIP_ROW}} + storedsolvals::Ptr{SCIP_LPSOLVALS} + validsoldirsol::Ptr{SCIP_SOL} + validsollp::Clonglong + validfarkaslp::Clonglong + validsoldirlp::Clonglong + validdegeneracylp::Clonglong + divenolddomchgs::Clonglong + lpicolssize::Cint + nlpicols::Cint + lpifirstchgcol::Cint + lpirowssize::Cint + nlpirows::Cint + lpifirstchgrow::Cint + chgcolssize::Cint + nchgcols::Cint + chgrowssize::Cint + nchgrows::Cint + colssize::Cint + soldirectionsize::Cint + ncols::Cint + lazycolssize::Cint + nlazycols::Cint + nremovablecols::Cint + firstnewcol::Cint + rowssize::Cint + nrows::Cint + nremovablerows::Cint + firstnewrow::Cint + looseobjvalinf::Cint + nloosevars::Cint + glbpseudoobjvalinf::Cint + pseudoobjvalinf::Cint + ndivingrows::Cint + ndivechgsides::Cint + divechgsidessize::Cint + divinglpiitlim::Cint + lpiitlim::Cint + lpifastmip::Cint + lpithreads::Cint + lpitiming::Cint + lpirandomseed::Cint + lpiscaling::Cint + lpirefactorinterval::Cint + lpipricing::SCIP_PRICING + lpsolstat::SCIP_LPSOLSTAT + lastlpalgo::SCIP_LPALGO + objsqrnormunreliable::Cuint + lpisolutionpolishing::Cuint + looseobjvalid::Cuint + glbpseudoobjvalid::Cuint + pseudoobjvalid::Cuint + flushdeletedcols::Cuint + flushaddedcols::Cuint + flushdeletedrows::Cuint + flushaddedrows::Cuint + updateintegrality::Cuint + flushed::Cuint + solved::Cuint + primalfeasible::Cuint + primalchecked::Cuint + dualfeasible::Cuint + dualchecked::Cuint + solisbasic::Cuint + rootlpisrelax::Cuint + isrelax::Cuint + installing::Cuint + strongbranching::Cuint + probing::Cuint + strongbranchprobing::Cuint + diving::Cuint + divingobjchg::Cuint + divinglazyapplied::Cuint + resolvelperror::Cuint + adjustlpval::Cuint + lpifromscratch::Cuint + lpipresolving::Cuint + lpilpinfo::Cuint + lpihasfeastol::Cuint + lpihasdualfeastol::Cuint + lpihasbarrierconvtol::Cuint + lpihasfastmip::Cuint + lpihasscaling::Cuint + lpihaspresolving::Cuint + lpihasrowrep::Cuint + lpihaspolishing::Cuint + lpihasrefactor::Cuint + lpirowrepswitch::Cdouble + divelpwasprimfeas::Cuint + divelpwasprimchecked::Cuint + divelpwasdualfeas::Cuint + divelpwasdualchecked::Cuint + hasprovedbound::Cuint +end const SCIP_LP = SCIP_Lp +const SCIP_ColExactSolVals = Cvoid + +const SCIP_COLEXACTSOLVALS = SCIP_ColExactSolVals + +const SCIP_RowExactSolVals = Cvoid + +const SCIP_ROWEXACTSOLVALS = SCIP_RowExactSolVals + +const SCIP_LpExactSolVals = Cvoid + +const SCIP_LPEXACTSOLVALS = SCIP_LpExactSolVals + +const SCIP_ColExact = Cvoid + +const SCIP_COLEXACT = SCIP_ColExact + +const SCIP_ProjShiftData = Cvoid + +const SCIP_PROJSHIFTDATA = SCIP_ProjShiftData + +@enum Ps_dualcostsel::UInt32 begin + PS_DUALCOSTSEL_NO = 0 + PS_DUALCOSTSEL_ACTIVE_FPLP = 1 + PS_DUALCOSTSEL_ACTIVE_EXLP = 2 +end + +const PS_DUALCOSTSEL = Ps_dualcostsel + +const SCIP_MatrixValsExact = Cvoid + +const SCIP_MATRIXVALSEXACT = SCIP_MatrixValsExact + const SCIP_Matrix = Cvoid const SCIP_MATRIX = SCIP_Matrix @@ -1723,6 +1914,7 @@ const SCIP_CONFIDENCELEVEL = SCIP_Confidencelevel SCIP_HASHMAPTYPE_POINTER = 1 SCIP_HASHMAPTYPE_REAL = 2 SCIP_HASHMAPTYPE_INT = 3 + SCIP_HASHMAPTYPE_LONG = 4 end const SCIP_HASHMAPTYPE = SCIP_Hashmaptype @@ -2022,6 +2214,26 @@ const SCIP_PropData = Cvoid const SCIP_PROPDATA = SCIP_PropData +const SCIP_RationalArray = Cvoid + +const SCIP_RATIONALARRAY = SCIP_RationalArray + +@enum SCIP_IsFpRepresentable::UInt32 begin + SCIP_ISFPREPRESENTABLE_UNKNOWN = 0 + SCIP_ISFPREPRESENTABLE_TRUE = 1 + SCIP_ISFPREPRESENTABLE_FALSE = 2 +end + +const SCIP_ISFPREPRESENTABLE = SCIP_IsFpRepresentable + +@enum SCIP_RoundModeRational::UInt32 begin + SCIP_R_ROUND_DOWNWARDS = 0 + SCIP_R_ROUND_UPWARDS = 1 + SCIP_R_ROUND_NEAREST = 2 +end + +const SCIP_ROUNDMODE_RAT = SCIP_RoundModeRational + const SCIP_Reader = Cvoid const SCIP_READER = SCIP_Reader @@ -2110,6 +2322,10 @@ const SCIP_SepaStore = Cvoid const SCIP_SEPASTORE = SCIP_SepaStore +const SCIP_SepaStoreExact = Cvoid + +const SCIP_SEPASTOREEXACT = SCIP_SepaStoreExact + @enum SCIP_Stage::UInt32 begin SCIP_STAGE_INIT = 0 SCIP_STAGE_PROBLEM = 1 @@ -2138,7 +2354,455 @@ end const SCIP_SETTING = SCIP_Setting -const SCIP_Set = Cvoid +const SCIP_Table = Cvoid + +const SCIP_TABLE = SCIP_Table + +const SCIP_DebugSolData = Cvoid + +const SCIP_DEBUGSOLDATA = SCIP_DebugSolData + +struct SCIP_Set + stage::SCIP_STAGE + scip::Ptr{SCIP} + paramset::Ptr{SCIP_PARAMSET} + buffer::Ptr{BMS_BUFMEM} + cleanbuffer::Ptr{BMS_BUFMEM} + readers::Ptr{Ptr{SCIP_READER}} + pricers::Ptr{Ptr{SCIP_PRICER}} + conshdlrs::Ptr{Ptr{SCIP_CONSHDLR}} + conshdlrs_sepa::Ptr{Ptr{SCIP_CONSHDLR}} + conshdlrs_enfo::Ptr{Ptr{SCIP_CONSHDLR}} + conshdlrs_include::Ptr{Ptr{SCIP_CONSHDLR}} + conflicthdlrs::Ptr{Ptr{SCIP_CONFLICTHDLR}} + presols::Ptr{Ptr{SCIP_PRESOL}} + relaxs::Ptr{Ptr{SCIP_RELAX}} + sepas::Ptr{Ptr{SCIP_SEPA}} + cutsels::Ptr{Ptr{SCIP_CUTSEL}} + props::Ptr{Ptr{SCIP_PROP}} + props_presol::Ptr{Ptr{SCIP_PROP}} + heurs::Ptr{Ptr{SCIP_HEUR}} + comprs::Ptr{Ptr{SCIP_COMPR}} + eventhdlrs::Ptr{Ptr{SCIP_EVENTHDLR}} + nodesels::Ptr{Ptr{SCIP_NODESEL}} + nodesel::Ptr{SCIP_NODESEL} + branchrules::Ptr{Ptr{SCIP_BRANCHRULE}} + iisfinders::Ptr{Ptr{SCIP_IISFINDER}} + disps::Ptr{Ptr{SCIP_DISP}} + tables::Ptr{Ptr{SCIP_TABLE}} + dialogs::Ptr{Ptr{SCIP_DIALOG}} + exprhdlrs::Ptr{Ptr{SCIP_EXPRHDLR}} + exprhdlrvar::Ptr{SCIP_EXPRHDLR} + exprhdlrval::Ptr{SCIP_EXPRHDLR} + exprhdlrsum::Ptr{SCIP_EXPRHDLR} + exprhdlrproduct::Ptr{SCIP_EXPRHDLR} + exprhdlrpow::Ptr{SCIP_EXPRHDLR} + nlpis::Ptr{Ptr{SCIP_NLPI}} + concsolvertypes::Ptr{Ptr{SCIP_CONCSOLVERTYPE}} + concsolvers::Ptr{Ptr{SCIP_CONCSOLVER}} + benders::Ptr{Ptr{SCIP_BENDERS}} + debugsoldata::Ptr{SCIP_DEBUGSOLDATA} + banditvtables::Ptr{Ptr{SCIP_BANDITVTABLE}} + extcodenames::Ptr{Ptr{Cchar}} + extcodedescs::Ptr{Ptr{Cchar}} + nreaders::Cint + readerssize::Cint + npricers::Cint + nactivepricers::Cint + pricerssize::Cint + nconshdlrs::Cint + conshdlrssize::Cint + nconflicthdlrs::Cint + conflicthdlrssize::Cint + npresols::Cint + presolssize::Cint + nrelaxs::Cint + relaxssize::Cint + nsepas::Cint + sepassize::Cint + ncutsels::Cint + cutselssize::Cint + nprops::Cint + propssize::Cint + nheurs::Cint + heurssize::Cint + ncomprs::Cint + comprssize::Cint + neventhdlrs::Cint + eventhdlrssize::Cint + nnodesels::Cint + nodeselssize::Cint + nbranchrules::Cint + branchrulessize::Cint + niisfinders::Cint + iisfinderssize::Cint + ndisps::Cint + dispssize::Cint + ntables::Cint + tablessize::Cint + ndialogs::Cint + dialogssize::Cint + nexprhdlrs::Cint + exprhdlrssize::Cint + nnlpis::Cint + nlpissize::Cint + nconcsolvertypes::Cint + concsolvertypessize::Cint + nconcsolvers::Cint + concsolverssize::Cint + nbenders::Cint + nactivebenders::Cint + benderssize::Cint + nextcodes::Cint + extcodessize::Cint + nbanditvtables::Cint + banditvtablessize::Cint + pricerssorted::Cuint + pricersnamesorted::Cuint + conflicthdlrssorted::Cuint + conflicthdlrsnamesorted::Cuint + presolssorted::Cuint + presolsnamesorted::Cuint + relaxssorted::Cuint + relaxsnamesorted::Cuint + sepassorted::Cuint + sepasnamesorted::Cuint + cutselssorted::Cuint + propssorted::Cuint + propspresolsorted::Cuint + propsnamesorted::Cuint + heurssorted::Cuint + heursnamesorted::Cuint + comprssorted::Cuint + comprsnamesorted::Cuint + branchrulessorted::Cuint + branchrulesnamesorted::Cuint + iisfinderssorted::Cuint + tablessorted::Cuint + exprhdlrssorted::Cuint + nlpissorted::Cuint + benderssorted::Cuint + bendersnamesorted::Cuint + limitchanged::Cuint + subscipsoff::Cuint + branch_scorefunc::Cchar + branch_firstsbchild::Cchar + branch_scorefac::Cdouble + branch_preferbinary::Cuint + branch_clamp::Cdouble + branch_midpull::Cdouble + branch_midpullreldomtrig::Cdouble + branch_lpgainnorm::Cchar + branch_delaypscost::Cuint + branch_divingpscost::Cuint + branch_collectancpscost::Cuint + branch_forceall::Cuint + branch_checksbsol::Cuint + branch_roundsbsol::Cuint + branch_sumadjustscore::Cuint + conf_maxvarsfac::Cdouble + conf_maxvarsfracres::Cdouble + conf_minmaxvars::Cint + conf_maxlploops::Cint + conf_lpiterations::Cint + conf_fuiplevels::Cint + conf_resfuiplevels::Cint + conf_interconss::Cint + conf_maxconss::Cint + conf_maxstoresize::Cint + conf_reconvlevels::Cint + conf_enable::Cuint + conf_cleanbnddepend::Cuint + conf_useprop::Cuint + conf_usegenres::Cuint + conf_useinflp::Cchar + conf_useboundlp::Cchar + conf_usesb::Cuint + conf_reduction::Cchar + conf_mbreduction::Cuint + conf_usepseudo::Cuint + conf_prefinfproof::Cuint + conf_preferbinary::Cuint + conf_allowlocal::Cuint + conf_settlelocal::Cuint + conf_repropagate::Cuint + conf_keepreprop::Cuint + conf_separate::Cuint + conf_dynamic::Cuint + conf_removable::Cuint + conf_depthscorefac::Cdouble + conf_proofscorefac::Cdouble + conf_uplockscorefac::Cdouble + conf_downlockscorefac::Cdouble + conf_scorefac::Cdouble + conf_restartnum::Cint + conf_restartfac::Cdouble + conf_ignorerelaxedbd::Cuint + conf_maxvarsdetectimpliedbounds::Cint + conf_fullshortenconflict::Cuint + conf_conflictweight::Cdouble + conf_conflictgraphweight::Cdouble + conf_weightsize::Cdouble + conf_weightrepropdepth::Cdouble + conf_weightvaliddepth::Cdouble + conf_sepaaltproofs::Cuint + conf_minimprove::Cdouble + conf_uselocalrows::Cuint + conf_maxcoefquot::Cdouble + conf_fixandcontinue::Cuint + cons_agelimit::Cint + cons_obsoleteage::Cint + cons_disableenfops::Cuint + disp_verblevel::SCIP_VERBLEVEL + disp_width::Cint + disp_freq::Cint + disp_headerfreq::Cint + disp_lpinfo::Cuint + disp_allviols::Cuint + disp_relevantstats::Cuint + heur_useuctsubscip::Cuint + history_valuebased::Cuint + history_allowmerge::Cuint + history_allowtransfer::Cuint + iisfinder_irreducible::Cuint + iisfinder_removebounds::Cuint + iisfinder_silent::Cuint + iisfinder_stopafterone::Cuint + iisfinder_removeunusedvars::Cuint + iisfinder_time::Cdouble + iisfinder_nodes::Clonglong + limit_time::Cdouble + limit_memory::Cdouble + limit_gap::Cdouble + limit_absgap::Cdouble + limit_primal::Cdouble + limit_dual::Cdouble + limit_nodes::Clonglong + limit_totalnodes::Clonglong + limit_stallnodes::Clonglong + limit_solutions::Cint + limit_bestsol::Cint + limit_maxsol::Cint + limit_maxorigsol::Cint + limit_restarts::Cint + limit_autorestartnodes::Cint + istimelimitfinite::Cuint + lp_solvefreq::Cint + lp_iterlim::Clonglong + lp_rootiterlim::Clonglong + lp_solvedepth::Cint + lp_minsolvedepth::Cint + lp_initalgorithm::Cchar + lp_resolvealgorithm::Cchar + lp_pricing::Cchar + lp_clearinitialprobinglp::Cuint + lp_resolverestore::Cuint + lp_freesolvalbuffers::Cuint + lp_colagelimit::Cint + lp_rowagelimit::Cint + lp_cleanupcols::Cuint + lp_cleanupcolsroot::Cuint + lp_cleanuprows::Cuint + lp_cleanuprowsroot::Cuint + lp_checkstability::Cuint + lp_conditionlimit::Cdouble + lp_markowitz::Cdouble + lp_checkprimfeas::Cuint + lp_checkdualfeas::Cuint + lp_checkfarkas::Cuint + lp_fastmip::Cint + lp_scaling::Cint + lp_presolving::Cuint + lp_lexdualalgo::Cuint + lp_lexdualrootonly::Cuint + lp_lexdualmaxrounds::Cint + lp_lexdualbasic::Cuint + lp_lexdualstalling::Cuint + lp_disablecutoff::Cint + lp_rowrepswitch::Cdouble + lp_threads::Cint + lp_resolveiterfac::Cdouble + lp_resolveitermin::Cint + lp_solutionpolishing::Cint + lp_refactorinterval::Cint + lp_alwaysgetduals::Cuint + nlp_disable::Cuint + nlp_solver::Ptr{Cchar} + mem_savefac::Cdouble + mem_arraygrowfac::Cdouble + mem_treegrowfac::Cdouble + mem_pathgrowfac::Cdouble + mem_arraygrowinit::Cint + mem_treegrowinit::Cint + mem_pathgrowinit::Cint + misc_catchctrlc::Cuint + misc_usevartable::Cuint + misc_useconstable::Cuint + misc_usesmalltables::Cuint + misc_resetstat::Cuint + misc_improvingsols::Cuint + misc_printreason::Cuint + misc_estimexternmem::Cuint + misc_avoidmemout::Cuint + misc_transorigsols::Cuint + misc_transsolsorig::Cuint + misc_calcintegral::Cuint + misc_finitesolstore::Cuint + misc_outputorigsol::Cuint + misc_allowstrongdualreds::Cuint + misc_allowweakdualreds::Cuint + misc_referencevalue::Cdouble + misc_usesymmetry::Cint + misc_debugsol::Ptr{Cchar} + misc_scaleobj::Cuint + misc_showdivingstats::Cuint + random_randomseedshift::Cint + random_randomseedshiftmultiplier::Cint + random_permutationseed::Cint + random_randomseed::Cint + random_permuteconss::Cuint + random_permutevars::Cuint + nodesel_childsel::Cchar + num_infinity::Cdouble + num_epsilon::Cdouble + num_sumepsilon::Cdouble + num_feastol::Cdouble + num_checkfeastolfac::Cdouble + num_lpfeastolfactor::Cdouble + num_dualfeastol::Cdouble + num_barrierconvtol::Cdouble + num_boundstreps::Cdouble + num_pseudocosteps::Cdouble + num_pseudocostdelta::Cdouble + num_recompfac::Cdouble + num_hugeval::Cdouble + num_relaxfeastol::Cdouble + presol_abortfac::Cdouble + presol_maxrounds::Cint + presol_maxrestarts::Cint + presol_clqtablefac::Cdouble + presol_restartfac::Cdouble + presol_immrestartfac::Cdouble + presol_subrestartfac::Cdouble + presol_restartminred::Cdouble + presol_donotmultaggr::Cuint + presol_donotaggr::Cuint + price_abortfac::Cdouble + price_maxvars::Cint + price_maxvarsroot::Cint + price_delvars::Cuint + price_delvarsroot::Cuint + decomp_benderslabels::Cuint + decomp_applybenders::Cuint + decomp_maxgraphedge::Cint + decomp_disablemeasures::Cuint + benders_soltol::Cdouble + benders_cutlpsol::Cuint + benders_copybenders::Cuint + prop_maxrounds::Cint + prop_maxroundsroot::Cint + prop_abortoncutoff::Cuint + reopt_objsimsol::Cdouble + reopt_objsimrootlp::Cdouble + reopt_objsimdelay::Cdouble + reopt_varorderinterdiction::Cchar + reopt_forceheurrestart::Cint + reopt_maxcutage::Cint + reopt_maxdiffofnodes::Cint + reopt_maxsavednodes::Cint + reopt_solvelp::Cint + reopt_solvelpdiff::Cint + reopt_savesols::Cint + reopt_commontimelimit::Cuint + reopt_enable::Cuint + reopt_reducetofrontier::Cuint + reopt_saveprop::Cuint + reopt_sbinit::Cuint + reopt_shrinkinner::Cuint + reopt_sepaglbinfsubtrees::Cuint + reopt_sepabestsol::Cuint + reopt_storevarhistory::Cuint + reopt_usepscost::Cuint + reopt_usecuts::Cuint + reopt_usesplitcons::Cuint + sepa_maxbounddist::Cdouble + sepa_maxlocalbounddist::Cdouble + sepa_maxcoefratio::Cdouble + sepa_maxcoefratiofacrowprep::Cdouble + sepa_minefficacy::Cdouble + sepa_minefficacyroot::Cdouble + sepa_minortho::Cdouble + sepa_minorthoroot::Cdouble + sepa_minactivityquot::Cdouble + sepa_orthofunc::Cchar + sepa_efficacynorm::Cchar + sepa_cutselrestart::Cchar + sepa_cutselsubscip::Cchar + sepa_filtercutpoolrel::Cuint + sepa_maxruns::Cint + sepa_maxrounds::Cint + sepa_maxroundsroot::Cint + sepa_maxroundsrootsubrun::Cint + sepa_maxaddrounds::Cint + sepa_maxstallrounds::Cint + sepa_maxstallroundsroot::Cint + sepa_maxcutsgenfactor::Cdouble + sepa_maxcutsrootgenfactor::Cdouble + sepa_maxcuts::Cint + sepa_maxcutsroot::Cint + sepa_cutagelimit::Cint + sepa_poolfreq::Cint + parallel_mode::Cint + parallel_minnthreads::Cint + parallel_maxnthreads::Cint + concurrent_changeseeds::Cuint + concurrent_changechildsel::Cuint + concurrent_commvarbnds::Cuint + concurrent_presolvebefore::Cuint + concurrent_initseed::Cint + concurrent_freqinit::Cdouble + concurrent_freqmax::Cdouble + concurrent_freqfactor::Cdouble + concurrent_targetprogress::Cdouble + concurrent_maxnsols::Cint + concurrent_nbestsols::Cint + concurrent_maxnsyncdelay::Cint + concurrent_minsyncdelay::Cdouble + concurrent_paramsetprefix::Ptr{Cchar} + time_clocktype::SCIP_CLOCKTYPE + time_enabled::Cuint + time_reading::Cuint + time_rareclockcheck::Cuint + time_statistictiming::Cuint + time_nlpieval::Cuint + compr_enable::Cuint + compr_time::Cdouble + visual_vbcfilename::Ptr{Cchar} + visual_bakfilename::Ptr{Cchar} + visual_realtime::Cuint + visual_dispsols::Cuint + visual_displb::Cuint + visual_objextern::Cuint + exact_enable::Cuint + exact_improvingsols::Cuint + exact_interleavedbstrat::Cint + exact_safedbmethod::Cchar + exact_psdualcolselection::Cint + exact_lpinfo::Cuint + exact_allownegslack::Cuint + exact_cutmaxdenom::Clonglong + exact_cutapproxmaxboundval::Clonglong + certificate_filename::Ptr{Cchar} + certificate_maxfilesize::Cdouble + read_initialconss::Cuint + read_dynamicconss::Cuint + read_dynamiccols::Cuint + read_dynamicrows::Cuint + write_allconss::Cuint + write_printzeros::Cuint + write_genoffset::Cint + write_implintlevel::Cint +end const SCIP_SET = SCIP_Set @@ -2170,23 +2834,29 @@ end const SCIP_SOLTYPE = SCIP_SolType +const SCIP_ValsExact = Cvoid + +const SCIP_VALSEXACT = SCIP_ValsExact + @enum SCIP_Status::UInt32 begin 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 + SCIP_STATUS_OPTIMAL = 1 + SCIP_STATUS_INFEASIBLE = 2 + SCIP_STATUS_UNBOUNDED = 3 + SCIP_STATUS_INFORUNBD = 4 + SCIP_STATUS_USERINTERRUPT = 10 + SCIP_STATUS_TERMINATE = 11 + SCIP_STATUS_NODELIMIT = 20 + SCIP_STATUS_TOTALNODELIMIT = 21 + SCIP_STATUS_STALLNODELIMIT = 22 + SCIP_STATUS_TIMELIMIT = 23 + SCIP_STATUS_MEMLIMIT = 24 + SCIP_STATUS_GAPLIMIT = 25 + SCIP_STATUS_PRIMALLIMIT = 26 + SCIP_STATUS_DUALLIMIT = 27 + SCIP_STATUS_SOLLIMIT = 28 + SCIP_STATUS_BESTSOLLIMIT = 29 + SCIP_STATUS_RESTARTLIMIT = 30 end const SCIP_STATUS = SCIP_Status @@ -2206,10 +2876,6 @@ const SCIP_BoundStore = Cvoid const SCIP_BOUNDSTORE = SCIP_BoundStore -const SCIP_Table = Cvoid - -const SCIP_TABLE = SCIP_Table - const SCIP_TableData = Cvoid const SCIP_TABLEDATA = SCIP_TableData @@ -2230,46 +2896,298 @@ end const SCIP_NODETYPE = SCIP_NodeType -const SCIP_Probingnode = Cvoid +const SCIP_LPiNorms = Cvoid + +const SCIP_LPINORMS = SCIP_LPiNorms + +struct SCIP_Probingnode + lpistate::Ptr{SCIP_LPISTATE} + lpinorms::Ptr{SCIP_LPINORMS} + ninitialcols::Cint + ninitialrows::Cint + ncols::Cint + nrows::Cint + origobjvars::Ptr{Ptr{SCIP_VAR}} + origobjvals::Ptr{Cdouble} + nchgdobjs::Cint + lpwasprimfeas::Cuint + lpwasprimchecked::Cuint + lpwasdualfeas::Cuint + lpwasdualchecked::Cuint +end const SCIP_PROBINGNODE = SCIP_Probingnode -const SCIP_Sibling = Cvoid +struct SCIP_Sibling + arraypos::Cint +end const SCIP_SIBLING = SCIP_Sibling -const SCIP_Child = Cvoid +struct SCIP_Child + arraypos::Cint +end const SCIP_CHILD = SCIP_Child -const SCIP_Leaf = Cvoid +struct SCIP_Leaf + lpstatefork::Ptr{SCIP_NODE} +end const SCIP_LEAF = SCIP_Leaf -const SCIP_Junction = Cvoid +struct SCIP_Junction + nchildren::Cint +end const SCIP_JUNCTION = SCIP_Junction -const SCIP_Pseudofork = Cvoid +struct SCIP_Pseudofork + addedcols::Ptr{Ptr{SCIP_COL}} + addedrows::Ptr{Ptr{SCIP_ROW}} + naddedcols::Cint + naddedrows::Cint + nchildren::Cint +end const SCIP_PSEUDOFORK = SCIP_Pseudofork -const SCIP_Fork = Cvoid +struct SCIP_Fork + data::NTuple{48, UInt8} +end + +function Base.getproperty(x::Ptr{SCIP_Fork}, f::Symbol) + f === :addedcols && return Ptr{Ptr{Ptr{SCIP_COL}}}(x + 0) + f === :addedrows && return Ptr{Ptr{Ptr{SCIP_ROW}}}(x + 8) + f === :lpistate && return Ptr{Ptr{SCIP_LPISTATE}}(x + 16) + f === :lpobjval && return Ptr{Cdouble}(x + 24) + f === :naddedcols && return Ptr{Cint}(x + 32) + f === :naddedrows && return Ptr{Cint}(x + 36) + f === :nlpistateref && return Ptr{Cint}(x + 40) + f === :nchildren && return (Ptr{Cuint}(x + 44), 0, 28) + f === :lpwasprimfeas && return (Ptr{Cuint}(x + 44), 28, 1) + f === :lpwasprimchecked && return (Ptr{Cuint}(x + 44), 29, 1) + f === :lpwasdualfeas && return (Ptr{Cuint}(x + 44), 30, 1) + f === :lpwasdualchecked && return (Ptr{Cuint}(x + 44), 31, 1) + return getfield(x, f) +end + +function Base.getproperty(x::SCIP_Fork, f::Symbol) + r = Ref{SCIP_Fork}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_Fork}, r) + fptr = getproperty(ptr, f) + begin + if fptr isa Ptr + return GC.@preserve(r, unsafe_load(fptr)) + else + (baseptr, offset, width) = fptr + ty = eltype(baseptr) + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = GC.@preserve(r, unsafe_load(baseptr32)) + if offset + width > 32 + u64 |= GC.@preserve(r, unsafe_load(baseptr32 + 4)) << 32 + end + u64 = u64 >> offset & (1 << width - 1) + return u64 % ty + end + end +end + +function Base.setproperty!(x::Ptr{SCIP_Fork}, f::Symbol, v) + fptr = getproperty(x, f) + if fptr isa Ptr + unsafe_store!(getproperty(x, f), v) + else + (baseptr, offset, width) = fptr + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = unsafe_load(baseptr32) + straddle = offset + width > 32 + if straddle + u64 |= unsafe_load(baseptr32 + 4) << 32 + end + mask = 1 << width - 1 + u64 &= ~(mask << offset) + u64 |= (unsigned(v) & mask) << offset + unsafe_store!(baseptr32, u64 & typemax(UInt32)) + if straddle + unsafe_store!(baseptr32 + 4, u64 >> 32) + end + end +end + +function Base.propertynames(x::SCIP_Fork, private::Bool = false) + (:addedcols, :addedrows, :lpistate, :lpobjval, :naddedcols, :naddedrows, :nlpistateref, :nchildren, :lpwasprimfeas, :lpwasprimchecked, :lpwasdualfeas, :lpwasdualchecked, if private + fieldnames(typeof(x)) + else + () + end...) +end const SCIP_FORK = SCIP_Fork -const SCIP_Subroot = Cvoid +struct SCIP_Subroot + data::NTuple{56, UInt8} +end + +function Base.getproperty(x::Ptr{SCIP_Subroot}, f::Symbol) + f === :cols && return Ptr{Ptr{Ptr{SCIP_COL}}}(x + 0) + f === :rows && return Ptr{Ptr{Ptr{SCIP_ROW}}}(x + 8) + f === :lpistate && return Ptr{Ptr{SCIP_LPISTATE}}(x + 16) + f === :lpobjval && return Ptr{Cdouble}(x + 24) + f === :ncols && return Ptr{Cint}(x + 32) + f === :nrows && return Ptr{Cint}(x + 36) + f === :nlpistateref && return Ptr{Cint}(x + 40) + f === :nchildren && return (Ptr{Cuint}(x + 44), 0, 30) + f === :lpwasprimfeas && return (Ptr{Cuint}(x + 44), 30, 1) + f === :lpwasprimchecked && return (Ptr{Cuint}(x + 44), 31, 1) + f === :lpwasdualfeas && return (Ptr{Cuint}(x + 48), 0, 1) + f === :lpwasdualchecked && return (Ptr{Cuint}(x + 48), 1, 1) + return getfield(x, f) +end + +function Base.getproperty(x::SCIP_Subroot, f::Symbol) + r = Ref{SCIP_Subroot}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_Subroot}, r) + fptr = getproperty(ptr, f) + begin + if fptr isa Ptr + return GC.@preserve(r, unsafe_load(fptr)) + else + (baseptr, offset, width) = fptr + ty = eltype(baseptr) + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = GC.@preserve(r, unsafe_load(baseptr32)) + if offset + width > 32 + u64 |= GC.@preserve(r, unsafe_load(baseptr32 + 4)) << 32 + end + u64 = u64 >> offset & (1 << width - 1) + return u64 % ty + end + end +end + +function Base.setproperty!(x::Ptr{SCIP_Subroot}, f::Symbol, v) + fptr = getproperty(x, f) + if fptr isa Ptr + unsafe_store!(getproperty(x, f), v) + else + (baseptr, offset, width) = fptr + baseptr32 = convert(Ptr{UInt32}, baseptr) + u64 = unsafe_load(baseptr32) + straddle = offset + width > 32 + if straddle + u64 |= unsafe_load(baseptr32 + 4) << 32 + end + mask = 1 << width - 1 + u64 &= ~(mask << offset) + u64 |= (unsigned(v) & mask) << offset + unsafe_store!(baseptr32, u64 & typemax(UInt32)) + if straddle + unsafe_store!(baseptr32 + 4, u64 >> 32) + end + end +end + +function Base.propertynames(x::SCIP_Subroot, private::Bool = false) + (:cols, :rows, :lpistate, :lpobjval, :ncols, :nrows, :nlpistateref, :nchildren, :lpwasprimfeas, :lpwasprimchecked, :lpwasdualfeas, :lpwasdualchecked, if private + fieldnames(typeof(x)) + else + () + end...) +end const SCIP_SUBROOT = SCIP_Subroot -const SCIP_PendingBdchg = Cvoid +struct SCIP_PendingBdchg + node::Ptr{SCIP_NODE} + var::Ptr{SCIP_VAR} + newbound::Cdouble + newboundexact::Ptr{SCIP_RATIONAL} + boundtype::SCIP_BOUNDTYPE + infercons::Ptr{SCIP_CONS} + inferprop::Ptr{SCIP_PROP} + inferinfo::Cint + probingchange::Cuint +end const SCIP_PENDINGBDCHG = SCIP_PendingBdchg -const SCIP_Tree = Cvoid +struct SCIP_Tree + root::Ptr{SCIP_NODE} + leaves::Ptr{SCIP_NODEPQ} + path::Ptr{Ptr{SCIP_NODE}} + focusnode::Ptr{SCIP_NODE} + focuslpfork::Ptr{SCIP_NODE} + focuslpstatefork::Ptr{SCIP_NODE} + focussubroot::Ptr{SCIP_NODE} + probingroot::Ptr{SCIP_NODE} + children::Ptr{Ptr{SCIP_NODE}} + siblings::Ptr{Ptr{SCIP_NODE}} + childrenprio::Ptr{Cdouble} + siblingsprio::Ptr{Cdouble} + divebdchgvars::NTuple{2, Ptr{Ptr{SCIP_VAR}}} + divebdchgdirs::NTuple{2, Ptr{SCIP_BRANCHDIR}} + divebdchgvals::NTuple{2, Ptr{Cdouble}} + pathnlpcols::Ptr{Cint} + pathnlprows::Ptr{Cint} + probinglpistate::Ptr{SCIP_LPISTATE} + focuslpistate::Ptr{SCIP_LPISTATE} + probinglpinorms::Ptr{SCIP_LPINORMS} + pendingbdchgs::Ptr{SCIP_PENDINGBDCHG} + probdiverelaxsol::Ptr{Cdouble} + probinglpobjval::Cdouble + nprobdiverelaxsol::Cint + focuslpstateforklpcount::Clonglong + lastbranchparentid::Clonglong + divebdchgsize::NTuple{2, Cint} + ndivebdchanges::NTuple{2, Cint} + pendingbdchgssize::Cint + npendingbdchgs::Cint + childrensize::Cint + nchildren::Cint + siblingssize::Cint + nsiblings::Cint + pathlen::Cint + pathsize::Cint + effectiverootdepth::Cint + updatedeffectiverootdepth::Cint + correctlpdepth::Cint + cutoffdepth::Cint + repropdepth::Cint + repropsubtreecount::Cint + probingsumchgdobjs::Cint + focusnodehaslp::Cuint + probingnodehaslp::Cuint + focuslpconstructed::Cuint + cutoffdelayed::Cuint + probinglpwasflushed::Cuint + probinglpwassolved::Cuint + probingloadlpistate::Cuint + probinglpwasrelax::Cuint + probingsolvedlp::Cuint + forcinglpmessage::Cuint + probingobjchanged::Cuint + sbprobing::Cuint + probinglpwasprimfeas::Cuint + probinglpwasprimchecked::Cuint + probinglpwasdualfeas::Cuint + probinglpwasdualchecked::Cuint + probinglphadsafebound::Cuint + probdiverelaxstored::Cuint + probdiverelaxincludeslp::Cuint +end const SCIP_TREE = SCIP_Tree +@enum SCIP_Vartype::UInt32 begin + SCIP_VARTYPE_BINARY = 0 + SCIP_VARTYPE_INTEGER = 1 + SCIP_VARTYPE_IMPLINT = 2 + SCIP_VARTYPE_CONTINUOUS = 3 +end + +const SCIP_VARTYPE = SCIP_Vartype + const SCIP_VarData = Cvoid const SCIP_VARDATA = SCIP_VarData @@ -2286,15 +3204,6 @@ end const SCIP_VARSTATUS = SCIP_Varstatus -@enum SCIP_Vartype::UInt32 begin - SCIP_VARTYPE_BINARY = 0 - SCIP_VARTYPE_INTEGER = 1 - SCIP_VARTYPE_IMPLINT = 2 - SCIP_VARTYPE_CONTINUOUS = 3 -end - -const SCIP_VARTYPE = SCIP_Vartype - @enum SCIP_DomchgType::UInt32 begin SCIP_DOMCHGTYPE_DYNAMIC = 0 SCIP_DOMCHGTYPE_BOTH = 1 @@ -2323,10 +3232,6 @@ 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 @@ -2359,18 +3264,38 @@ const SCIP_Original = Cvoid const SCIP_ORIGINAL = SCIP_Original +const SCIP_Loose = Cvoid + +const SCIP_LOOSE = SCIP_Loose + const SCIP_Aggregate = Cvoid const SCIP_AGGREGATE = SCIP_Aggregate +const SCIP_AggregateExact = Cvoid + +const SCIP_AGGREGATEEXACT = SCIP_AggregateExact + const SCIP_Multaggr = Cvoid const SCIP_MULTAGGR = SCIP_Multaggr +const SCIP_MultaggrExact = Cvoid + +const SCIP_MULTAGGREXACT = SCIP_MultaggrExact + const SCIP_Negate = Cvoid const SCIP_NEGATE = SCIP_Negate +const SCIP_VarDataExact = Cvoid + +const SCIP_VARDATAEXACT = SCIP_VarDataExact + +const SCIP_DomExact = Cvoid + +const SCIP_DOMEXACT = SCIP_DomExact + @enum SCIP_VBCColor::Int32 begin SCIP_VBCCOLOR_UNSOLVED = 3 SCIP_VBCCOLOR_SOLVED = 2 @@ -2389,134 +3314,23 @@ const SCIP_Visual = Cvoid const SCIP_VISUAL = SCIP_Visual function SCIPmessagePrintErrorHeader(sourcefile, sourceline) - ccall( - (:SCIPmessagePrintErrorHeader, libscip), - Cvoid, - (Ptr{Cchar}, Cint), - sourcefile, - sourceline, - ) -end - -function SCIPnlpiCreate( - nlpi, - name, - description, - priority, - nlpicopy, - nlpifree, - nlpigetsolverpointer, - nlpicreateproblem, - nlpifreeproblem, - nlpigetproblempointer, - nlpiaddvars, - nlpiaddconstraints, - nlpisetobjective, - nlpichgvarbounds, - nlpichgconssides, - nlpidelvarset, - nlpidelconsset, - nlpichglinearcoefs, - nlpichgexpr, - nlpichgobjconstant, - nlpisetinitialguess, - nlpisolve, - nlpigetsolstat, - nlpigettermstat, - nlpigetsolution, - nlpigetstatistics, - nlpidata, -) - ccall( - (:SCIPnlpiCreate, libscip), - SCIP_RETCODE, - ( - Ptr{Ptr{SCIP_NLPI}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - 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_NLPIDATA}, - ), - nlpi, - name, - description, - priority, - nlpicopy, - nlpifree, - nlpigetsolverpointer, - nlpicreateproblem, - nlpifreeproblem, - nlpigetproblempointer, - nlpiaddvars, - nlpiaddconstraints, - nlpisetobjective, - nlpichgvarbounds, - nlpichgconssides, - nlpidelvarset, - nlpidelconsset, - nlpichglinearcoefs, - nlpichgexpr, - nlpichgobjconstant, - nlpisetinitialguess, - nlpisolve, - nlpigetsolstat, - nlpigettermstat, - nlpigetsolution, - nlpigetstatistics, - nlpidata, - ) + ccall((:SCIPmessagePrintErrorHeader, libscip), Cvoid, (Ptr{Cchar}, Cint), sourcefile, sourceline) +end + +function SCIPnlpiCreate(nlpi, name, description, priority, nlpicopy, nlpifree, nlpigetsolverpointer, nlpicreateproblem, nlpifreeproblem, nlpigetproblempointer, nlpiaddvars, nlpiaddconstraints, nlpisetobjective, nlpichgvarbounds, nlpichgconssides, nlpidelvarset, nlpidelconsset, nlpichglinearcoefs, nlpichgexpr, nlpichgobjconstant, nlpisetinitialguess, nlpisolve, nlpigetsolstat, nlpigettermstat, nlpigetsolution, nlpigetstatistics, nlpidata) + ccall((:SCIPnlpiCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NLPI}}, Ptr{Cchar}, Ptr{Cchar}, Cint, 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_NLPIDATA}), nlpi, name, description, priority, nlpicopy, nlpifree, nlpigetsolverpointer, nlpicreateproblem, nlpifreeproblem, nlpigetproblempointer, nlpiaddvars, nlpiaddconstraints, nlpisetobjective, nlpichgvarbounds, nlpichgconssides, nlpidelvarset, nlpidelconsset, nlpichglinearcoefs, nlpichgexpr, nlpichgobjconstant, nlpisetinitialguess, nlpisolve, nlpigetsolstat, nlpigettermstat, nlpigetsolution, nlpigetstatistics, nlpidata) end function SCIPnlpiSetPriority(nlpi, priority) - ccall( - (:SCIPnlpiSetPriority, libscip), - Cvoid, - (Ptr{SCIP_NLPI}, Cint), - nlpi, - priority, - ) + ccall((:SCIPnlpiSetPriority, libscip), Cvoid, (Ptr{SCIP_NLPI}, Cint), nlpi, priority) end function SCIPnlpiCopyInclude(sourcenlpi, targetset) - ccall( - (:SCIPnlpiCopyInclude, libscip), - SCIP_RETCODE, - (Ptr{SCIP_NLPI}, Ptr{SCIP_SET}), - sourcenlpi, - targetset, - ) + ccall((:SCIPnlpiCopyInclude, libscip), SCIP_RETCODE, (Ptr{SCIP_NLPI}, Ptr{SCIP_SET}), sourcenlpi, targetset) end function SCIPnlpiFree(nlpi, set) - ccall( - (:SCIPnlpiFree, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_NLPI}}, Ptr{SCIP_SET}), - nlpi, - set, - ) + ccall((:SCIPnlpiFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NLPI}}, Ptr{SCIP_SET}), nlpi, set) end function SCIPnlpiInit(nlpi) @@ -2524,516 +3338,123 @@ function SCIPnlpiInit(nlpi) end function SCIPnlpiGetSolverPointer(set, nlpi, problem) - ccall( - (:SCIPnlpiGetSolverPointer, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), - set, - nlpi, - problem, - ) + ccall((:SCIPnlpiGetSolverPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), set, nlpi, problem) end function SCIPnlpiCreateProblem(set, nlpi, problem, name) - ccall( - (:SCIPnlpiCreateProblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}), - set, - nlpi, - problem, - name, - ) + ccall((:SCIPnlpiCreateProblem, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}), set, nlpi, problem, name) end function SCIPnlpiFreeProblem(set, nlpi, problem) - ccall( - (:SCIPnlpiFreeProblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), - set, - nlpi, - problem, - ) + ccall((:SCIPnlpiFreeProblem, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), set, nlpi, problem) end function SCIPnlpiGetProblemPointer(set, nlpi, problem) - ccall( - (:SCIPnlpiGetProblemPointer, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), - set, - nlpi, - problem, - ) + ccall((:SCIPnlpiGetProblemPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), set, nlpi, problem) end function SCIPnlpiAddVars(set, nlpi, problem, nvars, lbs, ubs, varnames) - ccall( - (:SCIPnlpiAddVars, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Ptr{Cchar}}, - ), - set, - nlpi, - problem, - nvars, - lbs, - ubs, - varnames, - ) -end - -function SCIPnlpiAddConstraints( - set, - nlpi, - problem, - nconss, - lhss, - rhss, - nlininds, - lininds, - linvals, - exprs, - names, -) - ccall( - (:SCIPnlpiAddConstraints, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Ptr{Cchar}}, - ), - set, - nlpi, - problem, - nconss, - lhss, - rhss, - nlininds, - lininds, - linvals, - exprs, - names, - ) -end - -function SCIPnlpiSetObjective( - set, - nlpi, - problem, - nlins, - lininds, - linvals, - expr, - constant, -) - ccall( - (:SCIPnlpiSetObjective, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{SCIP_EXPR}, - Cdouble, - ), - set, - nlpi, - problem, - nlins, - lininds, - linvals, - expr, - constant, - ) + ccall((:SCIPnlpiAddVars, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), set, nlpi, problem, nvars, lbs, ubs, varnames) +end + +function SCIPnlpiAddConstraints(set, nlpi, problem, nconss, lhss, rhss, nlininds, lininds, linvals, exprs, names) + ccall((:SCIPnlpiAddConstraints, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Ptr{Cchar}}), set, nlpi, problem, nconss, lhss, rhss, nlininds, lininds, linvals, exprs, names) +end + +function SCIPnlpiSetObjective(set, nlpi, problem, nlins, lininds, linvals, expr, constant) + ccall((:SCIPnlpiSetObjective, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_EXPR}, Cdouble), set, nlpi, problem, nlins, lininds, linvals, expr, constant) end function SCIPnlpiChgVarBounds(set, nlpi, problem, nvars, indices, lbs, ubs) - ccall( - (:SCIPnlpiChgVarBounds, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - set, - nlpi, - problem, - nvars, - indices, - lbs, - ubs, - ) + ccall((:SCIPnlpiChgVarBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), set, nlpi, problem, nvars, indices, lbs, ubs) end function SCIPnlpiChgConsSides(set, nlpi, problem, nconss, indices, lhss, rhss) - ccall( - (:SCIPnlpiChgConsSides, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - set, - nlpi, - problem, - nconss, - indices, - lhss, - rhss, - ) + ccall((:SCIPnlpiChgConsSides, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), set, nlpi, problem, nconss, indices, lhss, rhss) end function SCIPnlpiDelVarSet(set, nlpi, problem, dstats, dstatssize) - ccall( - (:SCIPnlpiDelVarSet, libscip), - SCIP_RETCODE, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), - set, - nlpi, - problem, - dstats, - dstatssize, - ) + ccall((:SCIPnlpiDelVarSet, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), set, nlpi, problem, dstats, dstatssize) end function SCIPnlpiDelConsSet(set, nlpi, problem, dstats, dstatssize) - ccall( - (:SCIPnlpiDelConsSet, libscip), - SCIP_RETCODE, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), - set, - nlpi, - problem, - dstats, - dstatssize, - ) + ccall((:SCIPnlpiDelConsSet, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), set, nlpi, problem, dstats, dstatssize) end function SCIPnlpiChgLinearCoefs(set, nlpi, problem, idx, nvals, varidxs, vals) - ccall( - (:SCIPnlpiChgLinearCoefs, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - ), - set, - nlpi, - problem, - idx, - nvals, - varidxs, - vals, - ) + ccall((:SCIPnlpiChgLinearCoefs, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Cint, Ptr{Cint}, Ptr{Cdouble}), set, nlpi, problem, idx, nvals, varidxs, vals) end function SCIPnlpiChgExpr(set, nlpi, problem, idxcons, expr) - ccall( - (:SCIPnlpiChgExpr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{SCIP_EXPR}, - ), - set, - nlpi, - problem, - idxcons, - expr, - ) + ccall((:SCIPnlpiChgExpr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{SCIP_EXPR}), set, nlpi, problem, idxcons, expr) end function SCIPnlpiChgObjConstant(set, nlpi, problem, objconstant) - ccall( - (:SCIPnlpiChgObjConstant, libscip), - SCIP_RETCODE, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cdouble), - set, - nlpi, - problem, - objconstant, - ) -end - -function SCIPnlpiSetInitialGuess( - set, - nlpi, - problem, - primalvalues, - consdualvalues, - varlbdualvalues, - varubdualvalues, -) - ccall( - (:SCIPnlpiSetInitialGuess, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - set, - nlpi, - problem, - primalvalues, - consdualvalues, - varlbdualvalues, - varubdualvalues, - ) + ccall((:SCIPnlpiChgObjConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cdouble), set, nlpi, problem, objconstant) +end + +function SCIPnlpiSetInitialGuess(set, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues) + ccall((:SCIPnlpiSetInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), set, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues) end function SCIPnlpiSolve(set, stat, nlpi, problem, param) - ccall( - (:SCIPnlpiSolve, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_STAT}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{SCIP_NLPPARAM}, - ), - set, - stat, - nlpi, - problem, - param, - ) + ccall((:SCIPnlpiSolve, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_NLPPARAM}), set, stat, nlpi, problem, param) end function SCIPnlpiGetSolstat(set, nlpi, problem) - ccall( - (:SCIPnlpiGetSolstat, libscip), - SCIP_NLPSOLSTAT, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), - set, - nlpi, - problem, - ) + ccall((:SCIPnlpiGetSolstat, libscip), SCIP_NLPSOLSTAT, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), set, nlpi, problem) end function SCIPnlpiGetTermstat(set, nlpi, problem) - ccall( - (:SCIPnlpiGetTermstat, libscip), - SCIP_NLPTERMSTAT, - (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), - set, - nlpi, - problem, - ) -end - -function SCIPnlpiGetSolution( - set, - nlpi, - problem, - primalvalues, - consdualvalues, - varlbdualvalues, - varubdualvalues, - objval, -) - ccall( - (:SCIPnlpiGetSolution, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Cdouble}, - ), - set, - nlpi, - problem, - primalvalues, - consdualvalues, - varlbdualvalues, - varubdualvalues, - objval, - ) + ccall((:SCIPnlpiGetTermstat, libscip), SCIP_NLPTERMSTAT, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), set, nlpi, problem) +end + +function SCIPnlpiGetSolution(set, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) + ccall((:SCIPnlpiGetSolution, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}), set, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) end function SCIPnlpiGetStatistics(set, nlpi, problem, statistics) - ccall( - (:SCIPnlpiGetStatistics, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_SET}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{SCIP_NLPSTATISTICS}, - ), - set, - nlpi, - problem, - statistics, - ) + ccall((:SCIPnlpiGetStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_NLPSTATISTICS}), set, nlpi, problem, statistics) end function BMSallocMemory_call(size, filename, line) - ccall( - (:BMSallocMemory_call, libscip), - Ptr{Cvoid}, - (Csize_t, Ptr{Cchar}, Cint), - size, - filename, - line, - ) + ccall((:BMSallocMemory_call, libscip), Ptr{Cvoid}, (Csize_t, Ptr{Cchar}, Cint), size, filename, line) end function BMSallocClearMemory_call(num, typesize, filename, line) - ccall( - (:BMSallocClearMemory_call, libscip), - Ptr{Cvoid}, - (Csize_t, Csize_t, Ptr{Cchar}, Cint), - num, - typesize, - filename, - line, - ) + ccall((:BMSallocClearMemory_call, libscip), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{Cchar}, Cint), num, typesize, filename, line) end function BMSallocMemoryArray_call(num, typesize, filename, line) - ccall( - (:BMSallocMemoryArray_call, libscip), - Ptr{Cvoid}, - (Csize_t, Csize_t, Ptr{Cchar}, Cint), - num, - typesize, - filename, - line, - ) + ccall((:BMSallocMemoryArray_call, libscip), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{Cchar}, Cint), num, typesize, filename, line) end function BMSreallocMemoryArray_call(ptr, num, typesize, filename, line) - ccall( - (:BMSreallocMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - ptr, - num, - typesize, - filename, - line, - ) + ccall((:BMSreallocMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), ptr, num, typesize, filename, line) end function BMSreallocMemory_call(ptr, size, filename, line) - ccall( - (:BMSreallocMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), - ptr, - size, - filename, - line, - ) + ccall((:BMSreallocMemory_call, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), ptr, size, filename, line) end function BMSduplicateMemory_call(source, size, filename, line) - ccall( - (:BMSduplicateMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), - source, - size, - filename, - line, - ) + ccall((:BMSduplicateMemory_call, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), source, size, filename, line) end function BMSduplicateMemoryArray_call(source, num, typesize, filename, line) - ccall( - (:BMSduplicateMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - source, - num, - typesize, - filename, - line, - ) + ccall((:BMSduplicateMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), source, num, typesize, filename, line) end function BMSfreeMemory_call(ptr, filename, line) - ccall( - (:BMSfreeMemory_call, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), - ptr, - filename, - line, - ) + ccall((:BMSfreeMemory_call, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), ptr, filename, line) end function BMSfreeMemoryNull_call(ptr, filename, line) - ccall( - (:BMSfreeMemoryNull_call, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), - ptr, - filename, - line, - ) + ccall((:BMSfreeMemoryNull_call, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), ptr, filename, line) end function BMSallocBlockMemory_call(blkmem, size, filename, line) - ccall( - (:BMSallocBlockMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BLKMEM}, Csize_t, Ptr{Cchar}, Cint), - blkmem, - size, - filename, - line, - ) + ccall((:BMSallocBlockMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Csize_t, Ptr{Cchar}, Cint), blkmem, size, filename, line) end function SCIPblkmem(scip) @@ -3041,190 +3462,47 @@ function SCIPblkmem(scip) end function BMSallocClearBlockMemory_call(blkmem, size, filename, line) - ccall( - (:BMSallocClearBlockMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BLKMEM}, Csize_t, Ptr{Cchar}, Cint), - blkmem, - size, - filename, - line, - ) + ccall((:BMSallocClearBlockMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Csize_t, Ptr{Cchar}, Cint), blkmem, size, filename, line) end function BMSallocBlockMemoryArray_call(blkmem, num, typesize, filename, line) - ccall( - (:BMSallocBlockMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BLKMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - blkmem, - num, - typesize, - filename, - line, - ) -end - -function BMSallocClearBlockMemoryArray_call( - blkmem, - num, - typesize, - filename, - line, -) - ccall( - (:BMSallocClearBlockMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BLKMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - blkmem, - num, - typesize, - filename, - line, - ) -end - -function BMSreallocBlockMemoryArray_call( - blkmem, - ptr, - oldnum, - newnum, - typesize, - filename, - line, -) - ccall( - (:BMSreallocBlockMemoryArray_call, libscip), - Ptr{Cvoid}, - ( - Ptr{BMS_BLKMEM}, - Ptr{Cvoid}, - Csize_t, - Csize_t, - Csize_t, - Ptr{Cchar}, - Cint, - ), - blkmem, - ptr, - oldnum, - newnum, - typesize, - filename, - line, - ) -end - -function BMSreallocBlockMemory_call( - blkmem, - ptr, - oldsize, - newsize, - filename, - line, -) - ccall( - (:BMSreallocBlockMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - blkmem, - ptr, - oldsize, - newsize, - filename, - line, - ) + ccall((:BMSallocBlockMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, num, typesize, filename, line) +end + +function BMSallocClearBlockMemoryArray_call(blkmem, num, typesize, filename, line) + ccall((:BMSallocClearBlockMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, num, typesize, filename, line) +end + +function BMSreallocBlockMemoryArray_call(blkmem, ptr, oldnum, newnum, typesize, filename, line) + ccall((:BMSreallocBlockMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, ptr, oldnum, newnum, typesize, filename, line) +end + +function BMSreallocBlockMemory_call(blkmem, ptr, oldsize, newsize, filename, line) + ccall((:BMSreallocBlockMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, ptr, oldsize, newsize, filename, line) end function BMSduplicateBlockMemory_call(blkmem, source, size, filename, line) - ccall( - (:BMSduplicateBlockMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), - blkmem, - source, - size, - filename, - line, - ) -end - -function BMSduplicateBlockMemoryArray_call( - blkmem, - source, - num, - typesize, - filename, - line, -) - ccall( - (:BMSduplicateBlockMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - blkmem, - source, - num, - typesize, - filename, - line, - ) -end - -function SCIPensureBlockMemoryArray_call( - scip, - arrayptr, - elemsize, - arraysize, - minsize, -) - ccall( - (:SCIPensureBlockMemoryArray_call, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cint}, Cint), - scip, - arrayptr, - elemsize, - arraysize, - minsize, - ) + ccall((:BMSduplicateBlockMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), blkmem, source, size, filename, line) +end + +function BMSduplicateBlockMemoryArray_call(blkmem, source, num, typesize, filename, line) + ccall((:BMSduplicateBlockMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, source, num, typesize, filename, line) +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 BMSfreeBlockMemory_call(blkmem, ptr, size, filename, line) - ccall( - (:BMSfreeBlockMemory_call, libscip), - Cvoid, - (Ptr{BMS_BLKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), - blkmem, - ptr, - size, - filename, - line, - ) + ccall((:BMSfreeBlockMemory_call, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), blkmem, ptr, size, filename, line) end function BMSfreeBlockMemoryNull_call(blkmem, ptr, size, filename, line) - ccall( - (:BMSfreeBlockMemoryNull_call, libscip), - Cvoid, - (Ptr{BMS_BLKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), - blkmem, - ptr, - size, - filename, - line, - ) + ccall((:BMSfreeBlockMemoryNull_call, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), blkmem, ptr, size, filename, line) end function BMSallocBufferMemory_call(buffer, size, filename, line) - ccall( - (:BMSallocBufferMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BUFMEM}, Csize_t, Ptr{Cchar}, Cint), - buffer, - size, - filename, - line, - ) + ccall((:BMSallocBufferMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Csize_t, Ptr{Cchar}, Cint), buffer, size, filename, line) end function SCIPbuffer(scip) @@ -3232,114 +3510,31 @@ function SCIPbuffer(scip) end function BMSallocBufferMemoryArray_call(buffer, num, typesize, filename, line) - ccall( - (:BMSallocBufferMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BUFMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - buffer, - num, - typesize, - filename, - line, - ) -end - -function BMSallocClearBufferMemoryArray_call( - buffer, - num, - typesize, - filename, - line, -) - ccall( - (:BMSallocClearBufferMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BUFMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - buffer, - num, - typesize, - filename, - line, - ) -end - -function BMSreallocBufferMemoryArray_call( - buffer, - ptr, - num, - typesize, - filename, - line, -) - ccall( - (:BMSreallocBufferMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - buffer, - ptr, - num, - typesize, - filename, - line, - ) + ccall((:BMSallocBufferMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), buffer, num, typesize, filename, line) +end + +function BMSallocClearBufferMemoryArray_call(buffer, num, typesize, filename, line) + ccall((:BMSallocClearBufferMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), buffer, num, typesize, filename, line) +end + +function BMSreallocBufferMemoryArray_call(buffer, ptr, num, typesize, filename, line) + ccall((:BMSreallocBufferMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), buffer, ptr, num, typesize, filename, line) end function BMSduplicateBufferMemory_call(buffer, source, size, filename, line) - ccall( - (:BMSduplicateBufferMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), - buffer, - source, - size, - filename, - line, - ) -end - -function BMSduplicateBufferMemoryArray_call( - buffer, - source, - num, - typesize, - filename, - line, -) - ccall( - (:BMSduplicateBufferMemoryArray_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), - buffer, - source, - num, - typesize, - filename, - line, - ) + ccall((:BMSduplicateBufferMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), buffer, source, size, filename, line) +end + +function BMSduplicateBufferMemoryArray_call(buffer, source, num, typesize, filename, line) + ccall((:BMSduplicateBufferMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), buffer, source, num, typesize, filename, line) end function BMSfreeBufferMemory_call(buffer, ptr, filename, line) - ccall( - (:BMSfreeBufferMemory_call, libscip), - Cvoid, - (Ptr{BMS_BUFMEM}, Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), - buffer, - ptr, - filename, - line, - ) + ccall((:BMSfreeBufferMemory_call, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), buffer, ptr, filename, line) end function BMSfreeBufferMemoryNull_call(buffer, ptr, filename, line) - ccall( - (:BMSfreeBufferMemoryNull_call, libscip), - Cvoid, - (Ptr{BMS_BUFMEM}, Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), - buffer, - ptr, - filename, - line, - ) + ccall((:BMSfreeBufferMemoryNull_call, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), buffer, ptr, filename, line) end function SCIPcleanbuffer(scip) @@ -3347,330 +3542,107 @@ function SCIPcleanbuffer(scip) end function SCIPsolveNLPParam(scip, param) - ccall( - (:SCIPsolveNLPParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, SCIP_NLPPARAM), - scip, - param, - ) + ccall((:SCIPsolveNLPParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM), scip, param) end function SCIPsolveNlpiParam(scip, nlpi, problem, param) - ccall( - (:SCIPsolveNlpiParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, SCIP_NLPPARAM), - scip, - nlpi, - problem, - param, - ) -end - -function SCIPshrinkDisjunctiveVarSet( - scip, - vars, - bounds, - boundtypes, - redundants, - nvars, - nredvars, - nglobalred, - setredundant, - glbinfeas, - fullshortening, -) - ccall( - (:SCIPshrinkDisjunctiveVarSet, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Cint, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cuint}, - Cuint, - ), - scip, - vars, - bounds, - boundtypes, - redundants, - nvars, - nredvars, - nglobalred, - setredundant, - glbinfeas, - fullshortening, - ) -end - -function SCIPcutsTightenCoefficients( - scip, - cutislocal, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - nchgcoefs, -) - ccall( - (:SCIPcutsTightenCoefficients, libscip), - Cuint, - ( - Ptr{SCIP}, - Cuint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - cutislocal, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - nchgcoefs, - ) + ccall((:SCIPsolveNlpiParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, SCIP_NLPPARAM), scip, nlpi, problem, param) +end + +function BMSreallocBufferMemory_call(buffer, ptr, size, filename, line) + ccall((:BMSreallocBufferMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), buffer, ptr, size, filename, line) +end + +const SCIP_LPiExact = Cvoid + +const SCIP_LPIEXACT = SCIP_LPiExact + +function SCIPshrinkDisjunctiveVarSet(scip, vars, bounds, boundtypes, redundants, nvars, nredvars, nglobalred, setredundant, glbinfeas, fullshortening) + ccall((:SCIPshrinkDisjunctiveVarSet, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Cuint), scip, vars, bounds, boundtypes, redundants, nvars, nredvars, nglobalred, setredundant, glbinfeas, fullshortening) +end + +function SCIPcutsTightenCoefficients(scip, cutislocal, cutcoefs, cutrhs, cutinds, cutnnz, nchgcoefs) + ccall((:SCIPcutsTightenCoefficients, libscip), Cuint, (Ptr{SCIP}, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, cutislocal, cutcoefs, cutrhs, cutinds, cutnnz, nchgcoefs) end function SCIPaggrRowCreate(scip, aggrrow) - ccall( - (:SCIPaggrRowCreate, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}), - scip, - aggrrow, - ) + ccall((:SCIPaggrRowCreate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}), scip, aggrrow) end function SCIPaggrRowFree(scip, aggrrow) - ccall( - (:SCIPaggrRowFree, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}), - scip, - aggrrow, - ) + ccall((:SCIPaggrRowFree, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}), scip, aggrrow) end function SCIPaggrRowPrint(scip, aggrrow, file) - ccall( - (:SCIPaggrRowPrint, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Libc.FILE}), - scip, - aggrrow, - file, - ) + ccall((:SCIPaggrRowPrint, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Libc.FILE}), scip, aggrrow, file) end function SCIPaggrRowCopy(scip, aggrrow, source) - ccall( - (:SCIPaggrRowCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}, Ptr{SCIP_AGGRROW}), - scip, - aggrrow, - source, - ) + ccall((:SCIPaggrRowCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}, Ptr{SCIP_AGGRROW}), scip, aggrrow, source) end function SCIPaggrRowAddRow(scip, aggrrow, row, weight, sidetype) - ccall( - (:SCIPaggrRowAddRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}, Cdouble, Cint), - scip, - aggrrow, - row, - weight, - sidetype, - ) + ccall((:SCIPaggrRowAddRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}, Cdouble, Cint), scip, aggrrow, row, weight, sidetype) +end + +function SCIPaggrRowAddRowSafely(scip, aggrrow, row, weight, sidetype, success) + ccall((:SCIPaggrRowAddRowSafely, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}, Cdouble, Cint, Ptr{Cuint}), scip, aggrrow, row, weight, sidetype, success) end function SCIPaggrRowCancelVarWithBound(scip, aggrrow, var, pos, valid) - ccall( - (:SCIPaggrRowCancelVarWithBound, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_VAR}, Cint, Ptr{Cuint}), - scip, - aggrrow, - var, - pos, - valid, - ) + ccall((:SCIPaggrRowCancelVarWithBound, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_VAR}, Cint, Ptr{Cuint}), scip, aggrrow, var, pos, valid) end function SCIPaggrRowAddObjectiveFunction(scip, aggrrow, rhs, scale) - ccall( - (:SCIPaggrRowAddObjectiveFunction, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cdouble, Cdouble), - scip, - aggrrow, - rhs, - scale, - ) -end - -function SCIPaggrRowAddCustomCons( - scip, - aggrrow, - inds, - vals, - len, - rhs, - weight, - rank, - _local, -) - ccall( - (:SCIPaggrRowAddCustomCons, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_AGGRROW}, - Ptr{Cint}, - Ptr{Cdouble}, - Cint, - Cdouble, - Cdouble, - Cint, - Cuint, - ), - scip, - aggrrow, - inds, - vals, - len, - rhs, - weight, - rank, - _local, - ) + ccall((:SCIPaggrRowAddObjectiveFunction, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cdouble, Cdouble), scip, aggrrow, rhs, scale) +end + +function SCIPaggrRowAddObjectiveFunctionSafely(scip, aggrrow, rhs, scale) + ccall((:SCIPaggrRowAddObjectiveFunctionSafely, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cdouble, Cdouble), scip, aggrrow, rhs, scale) +end + +function SCIPaggrRowAddCustomCons(scip, aggrrow, inds, vals, len, rhs, weight, rank, _local) + ccall((:SCIPaggrRowAddCustomCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cdouble, Cdouble, Cint, Cuint), scip, aggrrow, inds, vals, len, rhs, weight, rank, _local) end function SCIPaggrRowCalcEfficacyNorm(scip, aggrrow) - ccall( - (:SCIPaggrRowCalcEfficacyNorm, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_AGGRROW}), - scip, - aggrrow, - ) + ccall((:SCIPaggrRowCalcEfficacyNorm, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}), scip, aggrrow) end function SCIPaggrRowClear(aggrrow) ccall((:SCIPaggrRowClear, libscip), Cvoid, (Ptr{SCIP_AGGRROW},), aggrrow) end -function SCIPaggrRowSumRows( - scip, - aggrrow, - weights, - rowinds, - nrowinds, - sidetypebasis, - allowlocal, - negslack, - maxaggrlen, - valid, -) - ccall( - (:SCIPaggrRowSumRows, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_AGGRROW}, - Ptr{Cdouble}, - Ptr{Cint}, - Cint, - Cuint, - Cuint, - Cint, - Cint, - Ptr{Cuint}, - ), - scip, - aggrrow, - weights, - rowinds, - nrowinds, - sidetypebasis, - allowlocal, - negslack, - maxaggrlen, - valid, - ) +function SCIPaggrRowClearSafely(aggrrow) + ccall((:SCIPaggrRowClearSafely, libscip), Cvoid, (Ptr{SCIP_AGGRROW},), aggrrow) +end + +function SCIPaggrRowSumRows(scip, aggrrow, weights, rowinds, nrowinds, sidetypebasis, allowlocal, negslack, maxaggrlen, valid) + ccall((:SCIPaggrRowSumRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cuint, Cuint, Cint, Cint, Ptr{Cuint}), scip, aggrrow, weights, rowinds, nrowinds, sidetypebasis, allowlocal, negslack, maxaggrlen, valid) end function SCIPaggrRowRemoveZeros(scip, aggrrow, useglbbounds, valid) - ccall( - (:SCIPaggrRowRemoveZeros, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cuint, Ptr{Cuint}), - scip, - aggrrow, - useglbbounds, - valid, - ) + ccall((:SCIPaggrRowRemoveZeros, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cuint, Ptr{Cuint}), scip, aggrrow, useglbbounds, valid) end function SCIPaggrRowGetRowInds(aggrrow) - ccall( - (:SCIPaggrRowGetRowInds, libscip), - Ptr{Cint}, - (Ptr{SCIP_AGGRROW},), - aggrrow, - ) + ccall((:SCIPaggrRowGetRowInds, libscip), Ptr{Cint}, (Ptr{SCIP_AGGRROW},), aggrrow) end function SCIPaggrRowGetRowWeights(aggrrow) - ccall( - (:SCIPaggrRowGetRowWeights, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_AGGRROW},), - aggrrow, - ) + ccall((:SCIPaggrRowGetRowWeights, libscip), Ptr{Cdouble}, (Ptr{SCIP_AGGRROW},), aggrrow) end function SCIPaggrRowHasRowBeenAdded(aggrrow, row) - ccall( - (:SCIPaggrRowHasRowBeenAdded, libscip), - Cuint, - (Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}), - aggrrow, - row, - ) + ccall((:SCIPaggrRowHasRowBeenAdded, libscip), Cuint, (Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}), aggrrow, row) end function SCIPaggrRowGetAbsWeightRange(aggrrow, minabsrowweight, maxabsrowweight) - ccall( - (:SCIPaggrRowGetAbsWeightRange, libscip), - Cvoid, - (Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}), - aggrrow, - minabsrowweight, - maxabsrowweight, - ) + ccall((:SCIPaggrRowGetAbsWeightRange, libscip), Cvoid, (Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}), aggrrow, minabsrowweight, maxabsrowweight) end function SCIPaggrRowGetInds(aggrrow) - ccall( - (:SCIPaggrRowGetInds, libscip), - Ptr{Cint}, - (Ptr{SCIP_AGGRROW},), - aggrrow, - ) + ccall((:SCIPaggrRowGetInds, libscip), Ptr{Cint}, (Ptr{SCIP_AGGRROW},), aggrrow) end function SCIPaggrRowGetNNz(aggrrow) @@ -3678,23 +3650,15 @@ function SCIPaggrRowGetNNz(aggrrow) end function SCIPaggrRowGetValue(aggrrow, i) - ccall( - (:SCIPaggrRowGetValue, libscip), - Cdouble, - (Ptr{SCIP_AGGRROW}, Cint), - aggrrow, - i, - ) + ccall((:SCIPaggrRowGetValue, libscip), Cdouble, (Ptr{SCIP_AGGRROW}, Cint), aggrrow, i) +end + +function SCIPaggrRowGetValueSafely(aggrrow, i) + ccall((:SCIPaggrRowGetValueSafely, libscip), Cdouble, (Ptr{SCIP_AGGRROW}, Cint), aggrrow, i) end function SCIPaggrRowGetProbvarValue(aggrrow, probindex) - ccall( - (:SCIPaggrRowGetProbvarValue, libscip), - Cdouble, - (Ptr{SCIP_AGGRROW}, Cint), - aggrrow, - probindex, - ) + ccall((:SCIPaggrRowGetProbvarValue, libscip), Cdouble, (Ptr{SCIP_AGGRROW}, Cint), aggrrow, probindex) end function SCIPaggrRowGetRank(aggrrow) @@ -3713,753 +3677,116 @@ function SCIPaggrRowGetNRows(aggrrow) ccall((:SCIPaggrRowGetNRows, libscip), Cint, (Ptr{SCIP_AGGRROW},), aggrrow) end -function SCIPcalcMIR( - scip, - sol, - postprocess, - boundswitch, - usevbds, - allowlocal, - fixintegralrhs, - boundsfortrans, - boundtypesfortrans, - minfrac, - maxfrac, - scale, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, -) - ccall( - (:SCIPcalcMIR, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_SOL}, - Cuint, - Cdouble, - Cuint, - Cuint, - Cuint, - Ptr{Cint}, - Ptr{SCIP_BOUNDTYPE}, - Cdouble, - Cdouble, - Cdouble, - Ptr{SCIP_AGGRROW}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - sol, - postprocess, - boundswitch, - usevbds, - allowlocal, - fixintegralrhs, - boundsfortrans, - boundtypesfortrans, - minfrac, - maxfrac, - scale, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, - ) -end - -function SCIPcutGenerationHeuristicCMIR( - scip, - sol, - postprocess, - boundswitch, - usevbds, - allowlocal, - maxtestdelta, - boundsfortrans, - boundtypesfortrans, - minfrac, - maxfrac, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, -) - ccall( - (:SCIPcutGenerationHeuristicCMIR, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_SOL}, - Cuint, - Cdouble, - Cuint, - Cuint, - Cint, - Ptr{Cint}, - Ptr{SCIP_BOUNDTYPE}, - Cdouble, - Cdouble, - Ptr{SCIP_AGGRROW}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - sol, - postprocess, - boundswitch, - usevbds, - allowlocal, - maxtestdelta, - boundsfortrans, - boundtypesfortrans, - minfrac, - maxfrac, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, - ) -end - -function SCIPcalcFlowCover( - scip, - sol, - postprocess, - boundswitch, - allowlocal, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, -) - ccall( - (:SCIPcalcFlowCover, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_SOL}, - Cuint, - Cdouble, - Cuint, - Ptr{SCIP_AGGRROW}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - sol, - postprocess, - boundswitch, - allowlocal, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, - ) -end - -function SCIPcalcKnapsackCover( - scip, - sol, - allowlocal, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, -) - ccall( - (:SCIPcalcKnapsackCover, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_SOL}, - Cuint, - Ptr{SCIP_AGGRROW}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - sol, - allowlocal, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, - ) -end - -function SCIPcalcStrongCG( - scip, - sol, - postprocess, - boundswitch, - usevbds, - allowlocal, - minfrac, - maxfrac, - scale, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, -) - ccall( - (:SCIPcalcStrongCG, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_SOL}, - Cuint, - Cdouble, - Cuint, - Cuint, - Cdouble, - Cdouble, - Cdouble, - Ptr{SCIP_AGGRROW}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - sol, - postprocess, - boundswitch, - usevbds, - allowlocal, - minfrac, - maxfrac, - scale, - aggrrow, - cutcoefs, - cutrhs, - cutinds, - cutnnz, - cutefficacy, - cutrank, - cutislocal, - success, - ) -end - -function SCIPperformGenericDivingAlgorithm( - scip, - diveset, - worksol, - heur, - result, - nodeinfeasible, - iterlim, - divecontext, -) - ccall( - (:SCIPperformGenericDivingAlgorithm, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIVESET}, - Ptr{SCIP_SOL}, - Ptr{SCIP_HEUR}, - Ptr{SCIP_RESULT}, - Cuint, - Clonglong, - SCIP_DIVECONTEXT, - ), - scip, - diveset, - worksol, - heur, - result, - nodeinfeasible, - iterlim, - divecontext, - ) -end - -function SCIPcopyLargeNeighborhoodSearch( - sourcescip, - subscip, - varmap, - suffix, - fixedvars, - fixedvals, - nfixedvars, - uselprows, - copycuts, - success, - valid, -) - ccall( - (:SCIPcopyLargeNeighborhoodSearch, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_HASHMAP}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cint, - Cuint, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - sourcescip, - subscip, - varmap, - suffix, - fixedvars, - fixedvals, - nfixedvars, - uselprows, - copycuts, - success, - valid, - ) -end - -function SCIPaddTrustregionNeighborhoodConstraint( - scip, - subscip, - subvars, - violpenalty, -) - ccall( - (:SCIPaddTrustregionNeighborhoodConstraint, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cdouble), - scip, - subscip, - subvars, - violpenalty, - ) -end - -function SCIPincludeBanditvtable( - scip, - banditvtable, - name, - banditfree, - banditselect, - banditupdate, - banditreset, -) - ccall( - (:SCIPincludeBanditvtable, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_BANDITVTABLE}}, - Ptr{Cchar}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - banditvtable, - name, - banditfree, - banditselect, - banditupdate, - banditreset, - ) +function SCIPcalcMIR(scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, fixintegralrhs, boundsfortrans, boundtypesfortrans, minfrac, maxfrac, scale, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) + ccall((:SCIPcalcMIR, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cdouble, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{SCIP_BOUNDTYPE}, Cdouble, Cdouble, Cdouble, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, fixintegralrhs, boundsfortrans, boundtypesfortrans, minfrac, maxfrac, scale, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) +end + +function SCIPcutGenerationHeuristicCMIR(scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, maxtestdelta, boundsfortrans, boundtypesfortrans, minfrac, maxfrac, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) + ccall((:SCIPcutGenerationHeuristicCMIR, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cdouble, Cint, Cuint, Cint, Ptr{Cint}, Ptr{SCIP_BOUNDTYPE}, Cdouble, Cdouble, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, maxtestdelta, boundsfortrans, boundtypesfortrans, minfrac, maxfrac, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) +end + +function SCIPcalcFlowCover(scip, sol, postprocess, boundswitch, allowlocal, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) + ccall((:SCIPcalcFlowCover, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cdouble, Cuint, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, postprocess, boundswitch, allowlocal, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) +end + +function SCIPcalcKnapsackCover(scip, sol, allowlocal, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) + ccall((:SCIPcalcKnapsackCover, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, allowlocal, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) +end + +function SCIPcalcStrongCG(scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, minfrac, maxfrac, scale, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) + ccall((:SCIPcalcStrongCG, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cdouble, Cint, Cuint, Cdouble, Cdouble, Cdouble, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, minfrac, maxfrac, scale, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) +end + +function SCIPperformGenericDivingAlgorithm(scip, diveset, worksol, heur, result, nodeinfeasible, iterlim, nodelimit, lpresolvedomchgquot, divecontext) + ccall((:SCIPperformGenericDivingAlgorithm, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cuint, Clonglong, Cint, Cdouble, SCIP_DIVECONTEXT), scip, diveset, worksol, heur, result, nodeinfeasible, iterlim, nodelimit, lpresolvedomchgquot, divecontext) +end + +function SCIPcopyLargeNeighborhoodSearch(sourcescip, subscip, varmap, suffix, fixedvars, fixedvals, nfixedvars, uselprows, copycuts, success, valid) + ccall((:SCIPcopyLargeNeighborhoodSearch, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint, Cuint, Ptr{Cuint}, Ptr{Cuint}), sourcescip, subscip, varmap, suffix, fixedvars, fixedvals, nfixedvars, uselprows, copycuts, success, valid) +end + +function SCIPaddTrustregionNeighborhoodConstraint(sourcescip, targetscip, subvars, violpenalty) + ccall((:SCIPaddTrustregionNeighborhoodConstraint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cdouble), sourcescip, targetscip, subvars, violpenalty) +end + +function SCIPincludeBanditvtable(scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) + ccall((:SCIPincludeBanditvtable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDITVTABLE}}, Ptr{Cchar}, 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}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindBanditvtable, libscip), Ptr{SCIP_BANDITVTABLE}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPfreeBandit(scip, bandit) - ccall( - (:SCIPfreeBandit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}), - scip, - bandit, - ) + ccall((:SCIPfreeBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}), scip, bandit) end function SCIPresetBandit(scip, bandit, priorities, seed) - ccall( - (:SCIPresetBandit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BANDIT}, Ptr{Cdouble}, Cuint), - scip, - bandit, - priorities, - seed, - ) -end - -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}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_BENDERSDATA}, - ), - scip, - bendersptr, - name, - desc, - priority, - cutlp, - cutpseudo, - cutrelax, - shareauxvars, - bendersgetvar, - benderscreatesub, - bendersdata, - ) + ccall((:SCIPresetBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BANDIT}, Ptr{Cdouble}, Cuint), scip, bandit, priorities, seed) +end + +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}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, Cuint, Cuint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, Cuint, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, bendersptr, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, bendersgetvar, benderscreatesub, bendersdata) end function SCIPsetBendersCopy(scip, benders, benderscopy) - ccall( - (:SCIPsetBendersCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - benderscopy, - ) + ccall((:SCIPsetBendersCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderscopy) end function SCIPsetBendersFree(scip, benders, bendersfree) - ccall( - (:SCIPsetBendersFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - bendersfree, - ) + ccall((:SCIPsetBendersFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersfree) end function SCIPsetBendersInit(scip, benders, bendersinit) - ccall( - (:SCIPsetBendersInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - bendersinit, - ) + ccall((:SCIPsetBendersInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinit) end function SCIPsetBendersExit(scip, benders, bendersexit) - ccall( - (:SCIPsetBendersExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - bendersexit, - ) + ccall((:SCIPsetBendersExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexit) end function SCIPsetBendersInitpre(scip, benders, bendersinitpre) - ccall( - (:SCIPsetBendersInitpre, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - bendersinitpre, - ) + ccall((:SCIPsetBendersInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitpre) end function SCIPsetBendersExitpre(scip, benders, bendersexitpre) - ccall( - (:SCIPsetBendersExitpre, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - bendersexitpre, - ) + ccall((:SCIPsetBendersExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitpre) end function SCIPsetBendersInitsol(scip, benders, bendersinitsol) - ccall( - (:SCIPsetBendersInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - bendersinitsol, - ) + ccall((:SCIPsetBendersInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitsol) end function SCIPsetBendersExitsol(scip, benders, bendersexitsol) - ccall( - (:SCIPsetBendersExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - bendersexitsol, - ) + ccall((:SCIPsetBendersExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitsol) end function SCIPsetBendersPresubsolve(scip, benders, benderspresubsolve) - ccall( - (:SCIPsetBendersPresubsolve, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - benderspresubsolve, - ) -end - -function SCIPsetBendersSolveAndFreesub( - scip, - benders, - benderssolvesubconvex, - benderssolvesub, - bendersfreesub, -) - ccall( - (:SCIPsetBendersSolveAndFreesub, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), - scip, - benders, - benderssolvesubconvex, - benderssolvesub, - bendersfreesub, - ) + ccall((: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, - ) + ccall((:SCIPsetBendersPostsolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderspostsolve) end function SCIPsetBendersSubproblemComp(scip, benders, benderssubcomp) - ccall( - (:SCIPsetBendersSubproblemComp, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), - scip, - benders, - benderssubcomp, - ) + ccall((:SCIPsetBendersSubproblemComp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderssubcomp) end function SCIPfindBenders(scip, name) - ccall( - (:SCIPfindBenders, libscip), - Ptr{SCIP_BENDERS}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindBenders, libscip), Ptr{SCIP_BENDERS}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetBenders(scip) - ccall( - (:SCIPgetBenders, libscip), - Ptr{Ptr{SCIP_BENDERS}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetBenders, libscip), Ptr{Ptr{SCIP_BENDERS}}, (Ptr{SCIP},), scip) end function SCIPgetNBenders(scip) @@ -4471,670 +3798,163 @@ function SCIPgetNActiveBenders(scip) end function SCIPactivateBenders(scip, benders, nsubproblems) - ccall( - (:SCIPactivateBenders, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), - scip, - benders, - nsubproblems, - ) + ccall((:SCIPactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, nsubproblems) end function SCIPdeactivateBenders(scip, benders) - ccall( - (:SCIPdeactivateBenders, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}), - scip, - benders, - ) + ccall((:SCIPdeactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) end function SCIPsetBendersPriority(scip, benders, priority) - ccall( - (:SCIPsetBendersPriority, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), - scip, - benders, - priority, - ) -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{Cuint}, - Ptr{Cuint}, - SCIP_BENDERSENFOTYPE, - Cuint, - ), - scip, - benders, - sol, - result, - infeasible, - auxviol, - type, - checkint, - ) + ccall((:SCIPsetBendersPriority, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, priority) +end + +function SCIPsetBendersObjectiveType(scip, benders, objectivetype) + ccall((:SCIPsetBendersObjectiveType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, SCIP_BENDERSOBJTYPE), scip, benders, objectivetype) +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{Cuint}, Ptr{Cuint}, SCIP_BENDERSENFOTYPE, Cuint), scip, benders, sol, result, infeasible, auxviol, type, checkint) end function SCIPgetBendersMasterVar(scip, benders, var, mappedvar) - ccall( - (:SCIPgetBendersMasterVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), - scip, - benders, - var, - mappedvar, - ) + ccall((:SCIPgetBendersMasterVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, benders, var, mappedvar) end function SCIPgetBendersSubproblemVar(scip, benders, var, mappedvar, probnumber) - ccall( - (:SCIPgetBendersSubproblemVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Cint), - scip, - benders, - var, - mappedvar, - probnumber, - ) + ccall((:SCIPgetBendersSubproblemVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, benders, var, mappedvar, probnumber) end function SCIPgetBendersNSubproblems(scip, benders) - ccall( - (:SCIPgetBendersNSubproblems, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}), - scip, - benders, - ) + ccall((:SCIPgetBendersNSubproblems, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) end function SCIPaddBendersSubproblem(scip, benders, subproblem) - ccall( - (:SCIPaddBendersSubproblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP}), - scip, - benders, - subproblem, - ) + ccall((:SCIPaddBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP}), scip, benders, subproblem) end function SCIPsetupBendersSubproblem(scip, benders, sol, probnumber, type) - ccall( - (:SCIPsetupBendersSubproblem, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_BENDERS}, - Ptr{SCIP_SOL}, - Cint, - SCIP_BENDERSENFOTYPE, - ), - scip, - benders, - sol, - probnumber, - type, - ) -end - -function SCIPsolveBendersSubproblem( - scip, - benders, - sol, - probnumber, - infeasible, - solvecip, - objective, -) - ccall( - (:SCIPsolveBendersSubproblem, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_BENDERS}, - Ptr{SCIP_SOL}, - Cint, - Ptr{Cuint}, - Cuint, - Ptr{Cdouble}, - ), - scip, - benders, - sol, - probnumber, - infeasible, - solvecip, - objective, - ) + ccall((:SCIPsetupBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, SCIP_BENDERSENFOTYPE), scip, benders, sol, probnumber, type) +end + +function SCIPsolveBendersSubproblem(scip, benders, sol, probnumber, infeasible, solvecip, objective) + ccall((:SCIPsolveBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{Cuint}, Cuint, Ptr{Cdouble}), scip, benders, sol, probnumber, infeasible, 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{Cuint}), - scip, - benders, - sol, - probnumber, - optimal, - ) + 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{Cuint}), 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{Cuint}), - 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 SCIPapplyBendersDecomposition(scip, decompindex) - ccall( - (:SCIPapplyBendersDecomposition, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint), - scip, - decompindex, - ) -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}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cuint, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cuint, - Ptr{Cvoid}, - Ptr{SCIP_BENDERSCUTDATA}, - ), - scip, - benders, - benderscutptr, - name, - desc, - priority, - islpcut, - benderscutexec, - benderscutdata, - ) + 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{Cuint}), 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}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, benderscutptr, name, desc, priority, islpcut, benderscutexec, benderscutdata) end function SCIPsetBenderscutCopy(scip, benderscut, benderscutcopy) - ccall( - (:SCIPsetBenderscutCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), - scip, - benderscut, - benderscutcopy, - ) + ccall((:SCIPsetBenderscutCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutcopy) end function SCIPsetBenderscutFree(scip, benderscut, benderscutfree) - ccall( - (:SCIPsetBenderscutFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), - scip, - benderscut, - benderscutfree, - ) + ccall((:SCIPsetBenderscutFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutfree) end function SCIPsetBenderscutInit(scip, benderscut, benderscutinit) - ccall( - (:SCIPsetBenderscutInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), - scip, - benderscut, - benderscutinit, - ) + ccall((:SCIPsetBenderscutInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinit) end function SCIPsetBenderscutExit(scip, benderscut, benderscutexit) - ccall( - (:SCIPsetBenderscutExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), - scip, - benderscut, - benderscutexit, - ) + ccall((:SCIPsetBenderscutExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexit) end function SCIPsetBenderscutInitsol(scip, benderscut, benderscutinitsol) - ccall( - (:SCIPsetBenderscutInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), - scip, - benderscut, - benderscutinitsol, - ) + ccall((:SCIPsetBenderscutInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinitsol) end function SCIPsetBenderscutExitsol(scip, benderscut, benderscutexitsol) - ccall( - (:SCIPsetBenderscutExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), - scip, - benderscut, - benderscutexitsol, - ) + ccall((:SCIPsetBenderscutExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexitsol) end function SCIPsetBenderscutPriority(scip, benderscut, priority) - ccall( - (:SCIPsetBenderscutPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Cint), - scip, - benderscut, - priority, - ) + ccall((:SCIPsetBenderscutPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Cint), scip, benderscut, priority) end function SCIPstoreBendersCut(scip, benders, vars, vals, lhs, rhs, nvars) - ccall( - (:SCIPstoreBendersCut, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_BENDERS}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Cint, - ), - scip, - benders, - vars, - vals, - lhs, - rhs, - nvars, - ) + ccall((:SCIPstoreBendersCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Cint), scip, benders, vars, vals, lhs, rhs, nvars) end function SCIPapplyBendersStoredCuts(scip, benders) - ccall( - (:SCIPapplyBendersStoredCuts, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}), - scip, - benders, - ) -end - -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}, - Ptr{Cchar}, - Ptr{Cchar}, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Cdouble, - Ptr{SCIP_BRANCHRULEDATA}, - ), - scip, - branchruleptr, - name, - desc, - priority, - maxdepth, - maxbounddist, - branchruledata, - ) + ccall((:SCIPapplyBendersStoredCuts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) +end + +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}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cdouble, Ptr{SCIP_BRANCHRULEDATA}), scip, branchruleptr, name, desc, priority, maxdepth, maxbounddist, branchruledata) end function SCIPsetBranchruleCopy(scip, branchrule, branchcopy) - ccall( - (:SCIPsetBranchruleCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchcopy, - ) + ccall((:SCIPsetBranchruleCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchcopy) end function SCIPsetBranchruleFree(scip, branchrule, branchfree) - ccall( - (:SCIPsetBranchruleFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchfree, - ) + ccall((:SCIPsetBranchruleFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchfree) end function SCIPsetBranchruleInit(scip, branchrule, branchinit) - ccall( - (:SCIPsetBranchruleInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchinit, - ) + ccall((:SCIPsetBranchruleInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinit) end function SCIPsetBranchruleExit(scip, branchrule, branchexit) - ccall( - (:SCIPsetBranchruleExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchexit, - ) + ccall((:SCIPsetBranchruleExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexit) end function SCIPsetBranchruleInitsol(scip, branchrule, branchinitsol) - ccall( - (:SCIPsetBranchruleInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchinitsol, - ) + ccall((:SCIPsetBranchruleInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinitsol) end function SCIPsetBranchruleExitsol(scip, branchrule, branchexitsol) - ccall( - (:SCIPsetBranchruleExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchexitsol, - ) + ccall((:SCIPsetBranchruleExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexitsol) end function SCIPsetBranchruleExecLp(scip, branchrule, branchexeclp) - ccall( - (:SCIPsetBranchruleExecLp, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchexeclp, - ) + ccall((:SCIPsetBranchruleExecLp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexeclp) end function SCIPsetBranchruleExecExt(scip, branchrule, branchexecext) - ccall( - (:SCIPsetBranchruleExecExt, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchexecext, - ) + ccall((:SCIPsetBranchruleExecExt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecext) end function SCIPsetBranchruleExecPs(scip, branchrule, branchexecps) - ccall( - (:SCIPsetBranchruleExecPs, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), - scip, - branchrule, - branchexecps, - ) + ccall((:SCIPsetBranchruleExecPs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecps) end function SCIPfindBranchrule(scip, name) - ccall( - (:SCIPfindBranchrule, libscip), - Ptr{SCIP_BRANCHRULE}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindBranchrule, libscip), Ptr{SCIP_BRANCHRULE}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetBranchrules(scip) - ccall( - (:SCIPgetBranchrules, libscip), - Ptr{Ptr{SCIP_BRANCHRULE}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetBranchrules, libscip), Ptr{Ptr{SCIP_BRANCHRULE}}, (Ptr{SCIP},), scip) end function SCIPgetNBranchrules(scip) @@ -5142,67 +3962,19 @@ function SCIPgetNBranchrules(scip) end function SCIPsetBranchrulePriority(scip, branchrule, priority) - ccall( - (:SCIPsetBranchrulePriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), - scip, - branchrule, - priority, - ) + ccall((:SCIPsetBranchrulePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, priority) end function SCIPsetBranchruleMaxdepth(scip, branchrule, maxdepth) - ccall( - (:SCIPsetBranchruleMaxdepth, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), - scip, - branchrule, - maxdepth, - ) + ccall((:SCIPsetBranchruleMaxdepth, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, maxdepth) end function SCIPsetBranchruleMaxbounddist(scip, branchrule, maxbounddist) - ccall( - (:SCIPsetBranchruleMaxbounddist, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cdouble), - scip, - branchrule, - maxbounddist, - ) -end - -function SCIPgetLPBranchCands( - scip, - lpcands, - lpcandssol, - lpcandsfrac, - nlpcands, - npriolpcands, - nfracimplvars, -) - ccall( - (:SCIPgetLPBranchCands, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - lpcands, - lpcandssol, - lpcandsfrac, - nlpcands, - npriolpcands, - nfracimplvars, - ) + ccall((: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) @@ -5213,41 +3985,8 @@ 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, - ) +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) @@ -5275,15 +4014,7 @@ function SCIPgetNPrioExternBranchConts(scip) end function SCIPaddExternBranchCand(scip, var, score, solval) - ccall( - (:SCIPaddExternBranchCand, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), - scip, - var, - score, - solval, - ) + ccall((:SCIPaddExternBranchCand, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, score, solval) end function SCIPclearExternBranchCands(scip) @@ -5291,30 +4022,11 @@ function SCIPclearExternBranchCands(scip) end function SCIPcontainsExternBranchCand(scip, var) - ccall( - (:SCIPcontainsExternBranchCand, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) -end - -function SCIPgetPseudoBranchCands( - scip, - pseudocands, - npseudocands, - npriopseudocands, -) - ccall( - (:SCIPgetPseudoBranchCands, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}), - scip, - pseudocands, - npseudocands, - npriopseudocands, - ) + ccall((:SCIPcontainsExternBranchCand, libscip), Cuint, (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) @@ -5338,358 +4050,211 @@ function SCIPgetNPrioPseudoBranchImpls(scip) end function SCIPgetBranchScore(scip, var, downgain, upgain) - ccall( - (:SCIPgetBranchScore, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), - scip, - var, - downgain, - upgain, - ) + ccall((:SCIPgetBranchScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, downgain, upgain) end function SCIPgetBranchScoreMultiple(scip, var, nchildren, gains) - ccall( - (:SCIPgetBranchScoreMultiple, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), - scip, - var, - nchildren, - gains, - ) + ccall((:SCIPgetBranchScoreMultiple, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, nchildren, gains) end function SCIPgetBranchingPoint(scip, var, suggestion) - ccall( - (:SCIPgetBranchingPoint, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - suggestion, - ) + ccall((:SCIPgetBranchingPoint, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, suggestion) end function SCIPcalcNodeselPriority(scip, var, branchdir, targetvalue) - ccall( - (:SCIPcalcNodeselPriority, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), - scip, - var, - branchdir, - targetvalue, - ) + ccall((:SCIPcalcNodeselPriority, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), scip, var, branchdir, targetvalue) end function SCIPcalcChildEstimate(scip, var, targetvalue) - ccall( - (:SCIPcalcChildEstimate, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - targetvalue, - ) + ccall((:SCIPcalcChildEstimate, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, targetvalue) end function SCIPcalcChildEstimateIncrease(scip, var, varsol, targetvalue) - ccall( - (:SCIPcalcChildEstimateIncrease, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), - scip, - var, - varsol, - targetvalue, - ) + ccall((:SCIPcalcChildEstimateIncrease, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, varsol, targetvalue) end function SCIPcreateChild(scip, node, nodeselprio, estimate) - ccall( - (:SCIPcreateChild, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_NODE}}, Cdouble, Cdouble), - scip, - node, - nodeselprio, - estimate, - ) + ccall((:SCIPcreateChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NODE}}, Cdouble, Cdouble), scip, node, nodeselprio, estimate) end function SCIPbranchVar(scip, var, downchild, eqchild, upchild) - ccall( - (:SCIPbranchVar, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Ptr{Ptr{SCIP_NODE}}, - Ptr{Ptr{SCIP_NODE}}, - Ptr{Ptr{SCIP_NODE}}, - ), - scip, - var, - downchild, - eqchild, - upchild, - ) + ccall((:SCIPbranchVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, downchild, eqchild, upchild) end function SCIPbranchVarHole(scip, var, left, right, downchild, upchild) - ccall( - (:SCIPbranchVarHole, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Ptr{Ptr{SCIP_NODE}}, - Ptr{Ptr{SCIP_NODE}}, - ), - scip, - var, - left, - right, - downchild, - upchild, - ) + ccall((:SCIPbranchVarHole, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, left, right, downchild, upchild) end function SCIPbranchVarVal(scip, var, val, downchild, eqchild, upchild) - ccall( - (:SCIPbranchVarVal, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Cdouble, - Ptr{Ptr{SCIP_NODE}}, - Ptr{Ptr{SCIP_NODE}}, - Ptr{Ptr{SCIP_NODE}}, - ), - scip, - var, - val, - downchild, - eqchild, - upchild, - ) -end - -function SCIPbranchVarValNary( - scip, - var, - val, - n, - minwidth, - widthfactor, - nchildren, -) - ccall( - (:SCIPbranchVarValNary, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cint, Cdouble, Cdouble, Ptr{Cint}), - scip, - var, - val, - n, - minwidth, - widthfactor, - nchildren, - ) + ccall((: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, - ) + ccall((:SCIPbranchLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) end function SCIPbranchExtern(scip, result) - ccall( - (:SCIPbranchExtern, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RESULT}), - scip, - result, - ) + ccall((:SCIPbranchExtern, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) end function SCIPbranchPseudo(scip, result) - ccall( - (:SCIPbranchPseudo, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RESULT}), - scip, - result, - ) -end - -function SCIPincludeCompr( - scip, - name, - desc, - priority, - minnnodes, - comprcopy, - comprfree, - comprinit, - comprexit, - comprinitsol, - comprexitsol, - comprexec, - comprdata, -) - ccall( - (:SCIPincludeCompr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Ptr{Cvoid}, - Ptr{SCIP_COMPRDATA}, - ), - scip, - compr, - name, - desc, - priority, - minnnodes, - comprexec, - comprdata, - ) + ccall((:SCIPbranchPseudo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) +end + +function SCIPcreateDatatree(scip, datatree, capacity) + ccall((:SCIPcreateDatatree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DATATREE}}, Cint), scip, datatree, capacity) +end + +function SCIPcreateDatatreeInTree(scip, datatree, newtree, name, capacity) + ccall((:SCIPcreateDatatreeInTree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Ptr{SCIP_DATATREE}}, Ptr{Cchar}, Cint), scip, datatree, newtree, name, capacity) +end + +function SCIPinsertDatatreeBool(scip, datatree, name, value) + ccall((:SCIPinsertDatatreeBool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cuint), scip, datatree, name, value) +end + +function SCIPinsertDatatreeInt(scip, datatree, name, value) + ccall((:SCIPinsertDatatreeInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cint), scip, datatree, name, value) +end + +function SCIPinsertDatatreeLong(scip, datatree, name, value) + ccall((:SCIPinsertDatatreeLong, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Clonglong), scip, datatree, name, value) +end + +function SCIPinsertDatatreeReal(scip, datatree, name, value) + ccall((:SCIPinsertDatatreeReal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cdouble), scip, datatree, name, value) +end + +function SCIPinsertDatatreeString(scip, datatree, name, value) + ccall((:SCIPinsertDatatreeString, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cchar}), scip, datatree, name, value) +end + +function SCIPinsertDatatreeBoolArray(scip, datatree, name, values, nvalues) + ccall((:SCIPinsertDatatreeBoolArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cuint}, Cint), scip, datatree, name, values, nvalues) +end + +function SCIPinsertDatatreeIntArray(scip, datatree, name, values, nvalues) + ccall((:SCIPinsertDatatreeIntArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cint}, Cint), scip, datatree, name, values, nvalues) +end + +function SCIPinsertDatatreeLongArray(scip, datatree, name, values, nvalues) + ccall((:SCIPinsertDatatreeLongArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Clonglong}, Cint), scip, datatree, name, values, nvalues) +end + +function SCIPinsertDatatreeRealArray(scip, datatree, name, values, nvalues) + ccall((:SCIPinsertDatatreeRealArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cdouble}, Cint), scip, datatree, name, values, nvalues) +end + +function SCIPinsertDatatreeStringArray(scip, datatree, name, values, nvalues) + ccall((:SCIPinsertDatatreeStringArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Cint), scip, datatree, name, values, nvalues) +end + +function SCIPinsertDatatreeTree(scip, datatree, name, value) + ccall((:SCIPinsertDatatreeTree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{SCIP_DATATREE}), scip, datatree, name, value) +end + +function SCIPfreeDatatree(scip, datatree) + ccall((:SCIPfreeDatatree, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DATATREE}}), scip, datatree) +end + +function SCIPwriteDatatreeJson(scip, file, datatree) + ccall((:SCIPwriteDatatreeJson, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_DATATREE}), scip, file, datatree) +end + +function SCIPprintDatatreeAsTable(scip, datatree, file, sectionname, tablename) + ccall((:SCIPprintDatatreeAsTable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Libc.FILE}, Ptr{Cchar}, Ptr{Cchar}), scip, datatree, file, sectionname, tablename) +end + +function SCIPisCertified(scip) + ccall((:SCIPisCertified, libscip), Cuint, (Ptr{SCIP},), scip) +end + +function SCIPshouldCertificateTrackBounds(scip) + ccall((:SCIPshouldCertificateTrackBounds, libscip), Cuint, (Ptr{SCIP},), scip) +end + +function SCIPcertifyCons(scip, isorigfile, consname, sense, side, len, ind, val) + ccall((:SCIPcertifyCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cchar}, Cchar, Ptr{SCIP_RATIONAL}, Cint, Ptr{Cint}, Ptr{Ptr{SCIP_RATIONAL}}), scip, isorigfile, consname, sense, side, len, ind, val) +end + +function SCIPcertifyActivityVarBound(scip, linename, boundtype, newbound, ismaxactivity, constraint, variable, row, vals, lhs, rhs, vars, nvars) + ccall((:SCIPcertifyActivityVarBound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, SCIP_BOUNDTYPE, Cdouble, Cuint, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_ROWEXACT}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, linename, boundtype, newbound, ismaxactivity, constraint, variable, row, vals, lhs, rhs, vars, nvars) +end + +function SCIPcertifyActivityVarBoundExact(scip, linename, boundtype, newbound, ismaxactivity, constraint, variable, row, vals, lhs, rhs, vars, nvars) + ccall((:SCIPcertifyActivityVarBoundExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, SCIP_BOUNDTYPE, Ptr{SCIP_RATIONAL}, Cuint, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_ROWEXACT}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, linename, boundtype, newbound, ismaxactivity, constraint, variable, row, vals, lhs, rhs, vars, nvars) +end + +function SCIPcertifyActivityConflict(scip, cons, row, lhs, rhs, nvals, vals, vars, diff, userhs) + ccall((:SCIPcertifyActivityConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cint, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Cuint), scip, cons, row, lhs, rhs, nvals, vals, vars, diff, userhs) +end + +function SCIPaddCertificateAggrInfo(scip, aggrrow, aggrrows, weights, naggrrows, negslackrows, negslackweights, nnegslackrows) + ccall((:SCIPaddCertificateAggrInfo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Ptr{SCIP_ROW}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_ROW}}, Ptr{Cdouble}, Cint), scip, aggrrow, aggrrows, weights, naggrrows, negslackrows, negslackweights, nnegslackrows) +end + +function SCIPstoreCertificateActiveAggrInfo(scip, row) + ccall((:SCIPstoreCertificateActiveAggrInfo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPfreeCertificateActiveAggrInfo(scip) + ccall((:SCIPfreeCertificateActiveAggrInfo, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPaddCertificateMirInfo(scip) + ccall((:SCIPaddCertificateMirInfo, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPstoreCertificateActiveMirInfo(scip, row) + ccall((:SCIPstoreCertificateActiveMirInfo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPcertifyMirCut(scip, row) + ccall((:SCIPcertifyMirCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPfreeCertificateActiveMirInfo(scip) + ccall((:SCIPfreeCertificateActiveMirInfo, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeCompr(scip, name, desc, priority, minnnodes, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) + ccall((:SCIPincludeCompr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, compr, name, desc, priority, minnnodes, comprexec, comprdata) end function SCIPsetComprCopy(scip, compr, comprcopy) - ccall( - (:SCIPsetComprCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), - scip, - compr, - comprcopy, - ) + ccall((:SCIPsetComprCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprcopy) end function SCIPsetComprFree(scip, compr, comprfree) - ccall( - (:SCIPsetComprFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), - scip, - compr, - comprfree, - ) + ccall((:SCIPsetComprFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprfree) end function SCIPsetComprInit(scip, compr, comprinit) - ccall( - (:SCIPsetComprInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), - scip, - compr, - comprinit, - ) + ccall((:SCIPsetComprInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinit) end function SCIPsetComprExit(scip, compr, comprexit) - ccall( - (:SCIPsetComprExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), - scip, - compr, - comprexit, - ) + ccall((:SCIPsetComprExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexit) end function SCIPsetComprInitsol(scip, compr, comprinitsol) - ccall( - (:SCIPsetComprInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), - scip, - compr, - comprinitsol, - ) + ccall((:SCIPsetComprInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinitsol) end function SCIPsetComprExitsol(scip, compr, comprexitsol) - ccall( - (:SCIPsetComprExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), - scip, - compr, - comprexitsol, - ) + ccall((:SCIPsetComprExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexitsol) end function SCIPfindCompr(scip, name) - ccall( - (:SCIPfindCompr, libscip), - Ptr{SCIP_COMPR}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindCompr, libscip), Ptr{SCIP_COMPR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetComprs(scip) @@ -5701,82 +4266,19 @@ function SCIPgetNCompr(scip) end function SCIPsetComprPriority(scip, compr, priority) - ccall( - (:SCIPsetComprPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_COMPR}, Cint), - scip, - compr, - priority, - ) -end - -function SCIPincludeConcsolverType( - scip, - name, - prefpriodefault, - concsolvercreateinst, - concsolverdestroyinst, - concsolverinitseeds, - concsolverexec, - concsolvercopysolvdata, - concsolverstop, - concsolversyncwrite, - concsolversyncread, - concsolvertypefreedata, - data, -) - ccall( - (:SCIPincludeConcsolverType, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Cdouble, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_CONCSOLVERTYPEDATA}, - ), - scip, - name, - prefpriodefault, - concsolvercreateinst, - concsolverdestroyinst, - concsolverinitseeds, - concsolverexec, - concsolvercopysolvdata, - concsolverstop, - concsolversyncwrite, - concsolversyncread, - concsolvertypefreedata, - data, - ) + ccall((:SCIPsetComprPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Cint), scip, compr, priority) +end + +function SCIPincludeConcsolverType(scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) + ccall((:SCIPincludeConcsolverType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, 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}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindConcsolverType, libscip), Ptr{SCIP_CONCSOLVERTYPE}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetConcsolverTypes(scip) - ccall( - (:SCIPgetConcsolverTypes, libscip), - Ptr{Ptr{SCIP_CONCSOLVERTYPE}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetConcsolverTypes, libscip), Ptr{Ptr{SCIP_CONCSOLVERTYPE}}, (Ptr{SCIP},), scip) end function SCIPgetNConcsolverTypes(scip) @@ -5795,166 +4297,44 @@ function SCIPgetSyncstore(scip) ccall((:SCIPgetSyncstore, libscip), Ptr{SCIP_SYNCSTORE}, (Ptr{SCIP},), scip) end -function SCIPincludeConflicthdlr( - scip, - name, - desc, - priority, - conflictcopy, - conflictfree, - conflictinit, - conflictexit, - conflictinitsol, - conflictexitsol, - conflictexec, - conflicthdlrdata, -) - ccall( - (:SCIPincludeConflicthdlr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Ptr{Cvoid}, - Ptr{SCIP_CONFLICTHDLRDATA}, - ), - scip, - conflicthdlrptr, - name, - desc, - priority, - conflictexec, - conflicthdlrdata, - ) +function SCIPincludeConflicthdlr(scip, name, desc, priority, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) + ccall((:SCIPincludeConflicthdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, conflicthdlrptr, name, desc, priority, conflictexec, conflicthdlrdata) end function SCIPsetConflicthdlrCopy(scip, conflicthdlr, conflictcopy) - ccall( - (:SCIPsetConflicthdlrCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), - scip, - conflicthdlr, - conflictcopy, - ) + ccall((:SCIPsetConflicthdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictcopy) end function SCIPsetConflicthdlrFree(scip, conflicthdlr, conflictfree) - ccall( - (:SCIPsetConflicthdlrFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), - scip, - conflicthdlr, - conflictfree, - ) + ccall((:SCIPsetConflicthdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictfree) end function SCIPsetConflicthdlrInit(scip, conflicthdlr, conflictinit) - ccall( - (:SCIPsetConflicthdlrInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), - scip, - conflicthdlr, - conflictinit, - ) + ccall((:SCIPsetConflicthdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinit) end function SCIPsetConflicthdlrExit(scip, conflicthdlr, conflictexit) - ccall( - (:SCIPsetConflicthdlrExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), - scip, - conflicthdlr, - conflictexit, - ) + ccall((:SCIPsetConflicthdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexit) end function SCIPsetConflicthdlrInitsol(scip, conflicthdlr, conflictinitsol) - ccall( - (:SCIPsetConflicthdlrInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), - scip, - conflicthdlr, - conflictinitsol, - ) + ccall((:SCIPsetConflicthdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinitsol) end function SCIPsetConflicthdlrExitsol(scip, conflicthdlr, conflictexitsol) - ccall( - (:SCIPsetConflicthdlrExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), - scip, - conflicthdlr, - conflictexitsol, - ) + ccall((:SCIPsetConflicthdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexitsol) end function SCIPfindConflicthdlr(scip, name) - ccall( - (:SCIPfindConflicthdlr, libscip), - Ptr{SCIP_CONFLICTHDLR}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindConflicthdlr, libscip), Ptr{SCIP_CONFLICTHDLR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetConflicthdlrs(scip) - ccall( - (:SCIPgetConflicthdlrs, libscip), - Ptr{Ptr{SCIP_CONFLICTHDLR}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetConflicthdlrs, libscip), Ptr{Ptr{SCIP_CONFLICTHDLR}}, (Ptr{SCIP},), scip) end function SCIPgetNConflicthdlrs(scip) @@ -5962,2023 +4342,479 @@ function SCIPgetNConflicthdlrs(scip) end function SCIPsetConflicthdlrPriority(scip, conflicthdlr, priority) - ccall( - (:SCIPsetConflicthdlrPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Cint), - scip, - conflicthdlr, - priority, - ) + ccall((:SCIPsetConflicthdlrPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Cint), scip, conflicthdlr, priority) end function SCIPisConflictAnalysisApplicable(scip) - ccall( - (:SCIPisConflictAnalysisApplicable, libscip), - Cuint, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPisConflictAnalysisApplicable, libscip), Cuint, (Ptr{SCIP},), scip) end function SCIPinitConflictAnalysis(scip, conftype, iscutoffinvolved) - ccall( - (:SCIPinitConflictAnalysis, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, SCIP_CONFTYPE, Cuint), - scip, - conftype, - iscutoffinvolved, - ) + ccall((:SCIPinitConflictAnalysis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_CONFTYPE, Cuint), scip, conftype, iscutoffinvolved) end function SCIPaddConflictLb(scip, var, bdchgidx) - ccall( - (:SCIPaddConflictLb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), - scip, - var, - bdchgidx, - ) + ccall((:SCIPaddConflictLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) end function SCIPaddConflictRelaxedLb(scip, var, bdchgidx, relaxedlb) - ccall( - (:SCIPaddConflictRelaxedLb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), - scip, - var, - bdchgidx, - relaxedlb, - ) + ccall((:SCIPaddConflictRelaxedLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedlb) end function SCIPaddConflictUb(scip, var, bdchgidx) - ccall( - (:SCIPaddConflictUb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), - scip, - var, - bdchgidx, - ) + ccall((:SCIPaddConflictUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) end function SCIPaddConflictRelaxedUb(scip, var, bdchgidx, relaxedub) - ccall( - (:SCIPaddConflictRelaxedUb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), - scip, - var, - bdchgidx, - relaxedub, - ) + ccall((:SCIPaddConflictRelaxedUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedub) end function SCIPaddConflictBd(scip, var, boundtype, bdchgidx) - ccall( - (:SCIPaddConflictBd, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}), - scip, - var, - boundtype, - bdchgidx, - ) + ccall((:SCIPaddConflictBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}), scip, var, boundtype, bdchgidx) end function SCIPaddConflictRelaxedBd(scip, var, boundtype, bdchgidx, relaxedbd) - ccall( - (:SCIPaddConflictRelaxedBd, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble), - scip, - var, - boundtype, - bdchgidx, - relaxedbd, - ) + ccall((:SCIPaddConflictRelaxedBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, boundtype, bdchgidx, relaxedbd) end function SCIPaddConflictBinvar(scip, var) - ccall( - (:SCIPaddConflictBinvar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPaddConflictBinvar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPisConflictVarUsed(scip, var, boundtype, bdchgidx, used) - ccall( - (:SCIPisConflictVarUsed, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - SCIP_BOUNDTYPE, - Ptr{SCIP_BDCHGIDX}, - Ptr{Cuint}, - ), - scip, - var, - boundtype, - bdchgidx, - used, - ) + ccall((:SCIPisConflictVarUsed, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Ptr{Cuint}), scip, var, boundtype, bdchgidx, used) end function SCIPgetConflictVarLb(scip, var) - ccall( - (:SCIPgetConflictVarLb, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetConflictVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetConflictVarUb(scip, var) - ccall( - (:SCIPgetConflictVarUb, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetConflictVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPanalyzeConflict(scip, validdepth, success) - ccall( - (:SCIPanalyzeConflict, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Cuint}), - scip, - validdepth, - success, - ) + ccall((:SCIPanalyzeConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}), scip, validdepth, success) end function SCIPanalyzeConflictCons(scip, cons, success) - ccall( - (:SCIPanalyzeConflictCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), - scip, - cons, - success, - ) -end - -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}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Cint, - Cint, - Cint, - Cint, - Cint, - Cuint, - Cuint, - Cuint, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Cint, - Cuint, - 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, - Cuint, - ), - 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, - Cuint, - SCIP_PROPTIMING, - ), - scip, - conshdlr, - consprop, - propfreq, - delayprop, - proptiming, - ) + ccall((:SCIPanalyzeConflictCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) +end + +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, consgetpermsymgraph, consgetsignedpermsymgraph, conshdlrdata) + ccall((:SCIPincludeConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cuint, Cuint, Cuint, 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{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, consgetpermsymgraph, consgetsignedpermsymgraph, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cint, Cuint, 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, Cuint), 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, Cuint, SCIP_PROPTIMING), scip, conshdlr, consprop, propfreq, delayprop, proptiming) end function SCIPsetConshdlrEnforelax(scip, conshdlr, consenforelax) - ccall( - (:SCIPsetConshdlrEnforelax, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consenforelax, - ) + ccall((:SCIPsetConshdlrEnforelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenforelax) end function SCIPsetConshdlrCopy(scip, conshdlr, conshdlrcopy, conscopy) - ccall( - (:SCIPsetConshdlrCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), - scip, - conshdlr, - conshdlrcopy, - conscopy, - ) + ccall((:SCIPsetConshdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, conshdlr, conshdlrcopy, conscopy) end function SCIPsetConshdlrFree(scip, conshdlr, consfree) - ccall( - (:SCIPsetConshdlrFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consfree, - ) + ccall((:SCIPsetConshdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consfree) end function SCIPsetConshdlrInit(scip, conshdlr, consinit) - ccall( - (:SCIPsetConshdlrInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consinit, - ) + ccall((:SCIPsetConshdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinit) end function SCIPsetConshdlrExit(scip, conshdlr, consexit) - ccall( - (:SCIPsetConshdlrExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consexit, - ) + ccall((:SCIPsetConshdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexit) end function SCIPsetConshdlrInitsol(scip, conshdlr, consinitsol) - ccall( - (:SCIPsetConshdlrInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consinitsol, - ) + ccall((:SCIPsetConshdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitsol) end function SCIPsetConshdlrExitsol(scip, conshdlr, consexitsol) - ccall( - (:SCIPsetConshdlrExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consexitsol, - ) + ccall((:SCIPsetConshdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitsol) end function SCIPsetConshdlrInitpre(scip, conshdlr, consinitpre) - ccall( - (:SCIPsetConshdlrInitpre, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consinitpre, - ) + ccall((:SCIPsetConshdlrInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitpre) end function SCIPsetConshdlrExitpre(scip, conshdlr, consexitpre) - ccall( - (:SCIPsetConshdlrExitpre, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consexitpre, - ) -end - -function SCIPsetConshdlrPresol( - scip, - conshdlr, - conspresol, - maxprerounds, - presoltiming, -) - ccall( - (:SCIPsetConshdlrPresol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, SCIP_PRESOLTIMING), - scip, - conshdlr, - conspresol, - maxprerounds, - presoltiming, - ) + ccall((: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, - ) + ccall((:SCIPsetConshdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelete) end function SCIPsetConshdlrTrans(scip, conshdlr, constrans) - ccall( - (:SCIPsetConshdlrTrans, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - constrans, - ) + ccall((:SCIPsetConshdlrTrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, constrans) end function SCIPsetConshdlrInitlp(scip, conshdlr, consinitlp) - ccall( - (:SCIPsetConshdlrInitlp, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consinitlp, - ) + ccall((:SCIPsetConshdlrInitlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitlp) end function SCIPsetConshdlrResprop(scip, conshdlr, consresprop) - ccall( - (:SCIPsetConshdlrResprop, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consresprop, - ) + ccall((:SCIPsetConshdlrResprop, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consresprop) end function SCIPsetConshdlrActive(scip, conshdlr, consactive) - ccall( - (:SCIPsetConshdlrActive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consactive, - ) + ccall((:SCIPsetConshdlrActive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consactive) end function SCIPsetConshdlrDeactive(scip, conshdlr, consdeactive) - ccall( - (:SCIPsetConshdlrDeactive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consdeactive, - ) + ccall((:SCIPsetConshdlrDeactive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdeactive) end function SCIPsetConshdlrEnable(scip, conshdlr, consenable) - ccall( - (:SCIPsetConshdlrEnable, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consenable, - ) + ccall((:SCIPsetConshdlrEnable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenable) end function SCIPsetConshdlrDisable(scip, conshdlr, consdisable) - ccall( - (:SCIPsetConshdlrDisable, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consdisable, - ) + ccall((:SCIPsetConshdlrDisable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdisable) end function SCIPsetConshdlrDelvars(scip, conshdlr, consdelvars) - ccall( - (:SCIPsetConshdlrDelvars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consdelvars, - ) + ccall((:SCIPsetConshdlrDelvars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelvars) end function SCIPsetConshdlrPrint(scip, conshdlr, consprint) - ccall( - (:SCIPsetConshdlrPrint, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consprint, - ) + ccall((:SCIPsetConshdlrPrint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consprint) end function SCIPsetConshdlrParse(scip, conshdlr, consparse) - ccall( - (:SCIPsetConshdlrParse, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consparse, - ) + ccall((:SCIPsetConshdlrParse, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consparse) end function SCIPsetConshdlrGetVars(scip, conshdlr, consgetvars) - ccall( - (:SCIPsetConshdlrGetVars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consgetvars, - ) + ccall((:SCIPsetConshdlrGetVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetvars) end function SCIPsetConshdlrGetNVars(scip, conshdlr, consgetnvars) - ccall( - (:SCIPsetConshdlrGetNVars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consgetnvars, - ) + ccall((:SCIPsetConshdlrGetNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetnvars) end function SCIPsetConshdlrGetDiveBdChgs(scip, conshdlr, consgetdivebdchgs) - ccall( - (:SCIPsetConshdlrGetDiveBdChgs, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - scip, - conshdlr, - consgetdivebdchgs, - ) + ccall((:SCIPsetConshdlrGetDiveBdChgs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetdivebdchgs) +end + +function SCIPsetConshdlrGetPermsymGraph(scip, conshdlr, consgetpermsymgraph) + ccall((:SCIPsetConshdlrGetPermsymGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetpermsymgraph) +end + +function SCIPsetConshdlrGetSignedPermsymGraph(scip, conshdlr, consgetsignedpermsymgraph) + ccall((:SCIPsetConshdlrGetSignedPermsymGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetsignedpermsymgraph) end function SCIPfindConshdlr(scip, name) - ccall( - (:SCIPfindConshdlr, libscip), - Ptr{SCIP_CONSHDLR}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetConshdlrs(scip) - ccall( - (:SCIPgetConshdlrs, libscip), - Ptr{Ptr{SCIP_CONSHDLR}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetConshdlrs, libscip), Ptr{Ptr{SCIP_CONSHDLR}}, (Ptr{SCIP},), scip) end function SCIPgetNConshdlrs(scip) ccall((:SCIPgetNConshdlrs, libscip), Cint, (Ptr{SCIP},), scip) 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}}, - Ptr{Cchar}, - Ptr{SCIP_CONSHDLR}, - Ptr{SCIP_CONSDATA}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - scip, - cons, - str, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - success, - ) +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}}, Ptr{Cchar}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONSDATA}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), scip, cons, str, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, success) end function SCIPcaptureCons(scip, cons) - ccall( - (:SCIPcaptureCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPcaptureCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPreleaseCons(scip, cons) - ccall( - (:SCIPreleaseCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}), - scip, - cons, - ) + ccall((:SCIPreleaseCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}), scip, cons) end function SCIPchgConsName(scip, cons, name) - ccall( - (:SCIPchgConsName, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cchar}), - scip, - cons, - name, - ) + ccall((:SCIPchgConsName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cchar}), scip, cons, name) end function SCIPsetConsInitial(scip, cons, initial) - ccall( - (:SCIPsetConsInitial, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - initial, - ) + ccall((:SCIPsetConsInitial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, initial) end function SCIPsetConsSeparated(scip, cons, separate) - ccall( - (:SCIPsetConsSeparated, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - separate, - ) + ccall((:SCIPsetConsSeparated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, separate) end function SCIPsetConsEnforced(scip, cons, enforce) - ccall( - (:SCIPsetConsEnforced, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - enforce, - ) + ccall((:SCIPsetConsEnforced, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, enforce) end function SCIPsetConsChecked(scip, cons, check) - ccall( - (:SCIPsetConsChecked, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - check, - ) + ccall((:SCIPsetConsChecked, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, check) end function SCIPsetConsPropagated(scip, cons, propagate) - ccall( - (:SCIPsetConsPropagated, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - propagate, - ) + ccall((:SCIPsetConsPropagated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, propagate) end function SCIPsetConsLocal(scip, cons, _local) - ccall( - (:SCIPsetConsLocal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - _local, - ) + ccall((:SCIPsetConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, _local) end function SCIPsetConsModifiable(scip, cons, modifiable) - ccall( - (:SCIPsetConsModifiable, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - modifiable, - ) + ccall((:SCIPsetConsModifiable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, modifiable) end function SCIPsetConsDynamic(scip, cons, dynamic) - ccall( - (:SCIPsetConsDynamic, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - dynamic, - ) + ccall((:SCIPsetConsDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, dynamic) end function SCIPsetConsRemovable(scip, cons, removable) - ccall( - (:SCIPsetConsRemovable, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - removable, - ) + ccall((:SCIPsetConsRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, removable) end function SCIPsetConsStickingAtNode(scip, cons, stickingatnode) - ccall( - (:SCIPsetConsStickingAtNode, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - stickingatnode, - ) + ccall((:SCIPsetConsStickingAtNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, stickingatnode) end function SCIPupdateConsFlags(scip, cons0, cons1) - ccall( - (:SCIPupdateConsFlags, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), - scip, - cons0, - cons1, - ) + ccall((:SCIPupdateConsFlags, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons0, cons1) end function SCIPtransformCons(scip, cons, transcons) - ccall( - (:SCIPtransformCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), - scip, - cons, - transcons, - ) + ccall((:SCIPtransformCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) end function SCIPtransformConss(scip, nconss, conss, transconss) - ccall( - (:SCIPtransformConss, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), - scip, - nconss, - conss, - transconss, - ) + ccall((:SCIPtransformConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) end function SCIPgetTransformedCons(scip, cons, transcons) - ccall( - (:SCIPgetTransformedCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), - scip, - cons, - transcons, - ) + ccall((:SCIPgetTransformedCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) end function SCIPgetTransformedConss(scip, nconss, conss, transconss) - ccall( - (:SCIPgetTransformedConss, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), - scip, - nconss, - conss, - transconss, - ) + ccall((:SCIPgetTransformedConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) end function SCIPaddConsAge(scip, cons, deltaage) - ccall( - (:SCIPaddConsAge, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), - scip, - cons, - deltaage, - ) + ccall((:SCIPaddConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, deltaage) end function SCIPincConsAge(scip, cons) - ccall( - (:SCIPincConsAge, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPincConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPresetConsAge(scip, cons) - ccall( - (:SCIPresetConsAge, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPresetConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPenableCons(scip, cons) - ccall( - (:SCIPenableCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPenableCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdisableCons(scip, cons) - ccall( - (:SCIPdisableCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPdisableCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPenableConsSeparation(scip, cons) - ccall( - (:SCIPenableConsSeparation, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPenableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdisableConsSeparation(scip, cons) - ccall( - (:SCIPdisableConsSeparation, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPdisableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPenableConsPropagation(scip, cons) - ccall( - (:SCIPenableConsPropagation, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPenableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdisableConsPropagation(scip, cons) - ccall( - (:SCIPdisableConsPropagation, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPdisableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPmarkConsPropagate(scip, cons) - ccall( - (:SCIPmarkConsPropagate, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPunmarkConsPropagate(scip, cons) - ccall( - (:SCIPunmarkConsPropagate, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPunmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPaddConsLocksType(scip, cons, locktype, nlockspos, nlocksneg) - ccall( - (:SCIPaddConsLocksType, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_LOCKTYPE, Cint, Cint), - scip, - cons, - locktype, - nlockspos, - nlocksneg, - ) + ccall((:SCIPaddConsLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_LOCKTYPE, Cint, Cint), scip, cons, locktype, nlockspos, nlocksneg) end function SCIPaddConsLocks(scip, cons, nlockspos, nlocksneg) - ccall( - (:SCIPaddConsLocks, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cint, Cint), - scip, - cons, - nlockspos, - nlocksneg, - ) -end - -function SCIPcheckCons( - scip, - cons, - sol, - checkintegrality, - checklprows, - printreason, - result, -) - ccall( - (:SCIPcheckCons, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_CONS}, - Ptr{SCIP_SOL}, - Cuint, - Cuint, - Cuint, - Ptr{SCIP_RESULT}, - ), - scip, - cons, - sol, - checkintegrality, - checklprows, - printreason, - result, - ) + 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}, Cuint, Cuint, Cuint, 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}, Cuint, Cuint, Ptr{SCIP_RESULT}), - scip, - cons, - solinfeasible, - objinfeasible, - result, - ) + ccall((:SCIPenfopsCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint, Cuint, 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}, Cuint, Ptr{SCIP_RESULT}), - scip, - cons, - solinfeasible, - result, - ) + ccall((:SCIPenfolpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint, 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}, Cuint, Ptr{SCIP_RESULT}), - scip, - cons, - sol, - solinfeasible, - result, - ) + ccall((:SCIPenforelaxCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Cuint, 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{Cuint}), - scip, - cons, - infeasible, - ) + ccall((:SCIPinitlpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, infeasible) end function SCIPsepalpCons(scip, cons, result) - ccall( - (:SCIPsepalpCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RESULT}), - scip, - cons, - result, - ) + ccall((:SCIPsepalpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RESULT}), scip, cons, result) end function SCIPsepasolCons(scip, cons, sol, result) - ccall( - (:SCIPsepasolCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), - scip, - cons, - sol, - result, - ) + ccall((:SCIPsepasolCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cons, sol, result) end function SCIPpropCons(scip, cons, proptiming, result) - ccall( - (:SCIPpropCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_PROPTIMING, Ptr{SCIP_RESULT}), - scip, - cons, - proptiming, - result, - ) -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, - ) + 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, - ) + ccall((:SCIPactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPdeactiveCons(scip, cons) - ccall( - (:SCIPdeactiveCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPdeactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPprintCons(scip, cons, file) - ccall( - (:SCIPprintCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Libc.FILE}), - scip, - cons, - file, - ) + ccall((:SCIPprintCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Libc.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{Cuint}), - scip, - cons, - vars, - varssize, - success, - ) + ccall((:SCIPgetConsVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cuint}), 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{Cuint}), - scip, - cons, - nvars, - success, - ) -end - -function SCIPcopyPlugins( - sourcescip, - targetscip, - copyreaders, - copypricers, - copyconshdlrs, - copyconflicthdlrs, - copypresolvers, - copyrelaxators, - copyseparators, - copycutselectors, - copypropagators, - copyheuristics, - copyeventhdlrs, - copynodeselectors, - copybranchrules, - copydisplays, - copydialogs, - copytables, - copyexprhdlrs, - copynlpis, - passmessagehdlr, - valid, -) - ccall( - (:SCIPcopyPlugins, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - sourcescip, - targetscip, - copyreaders, - copypricers, - copyconshdlrs, - copyconflicthdlrs, - copypresolvers, - copyrelaxators, - copyseparators, - copycutselectors, - copypropagators, - copyheuristics, - copyeventhdlrs, - copynodeselectors, - copybranchrules, - copydisplays, - copydialogs, - copytables, - copyexprhdlrs, - copynlpis, - passmessagehdlr, - valid, - ) + ccall((:SCIPgetConsNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cint}, Ptr{Cuint}), scip, cons, nvars, success) end -function SCIPcopyBenders(sourcescip, targetscip, varmap, threadsafe, valid) - ccall( - (:SCIPcopyBenders, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Cuint, Ptr{Cuint}), - sourcescip, - targetscip, - varmap, - threadsafe, - valid, - ) +function SCIPgetConsPermsymGraph(scip, cons, graph, success) + ccall((:SCIPgetConsPermsymGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SYM_GRAPH}, Ptr{Cuint}), scip, cons, graph, success) end -function SCIPcopyProb(sourcescip, targetscip, varmap, consmap, _global, name) - ccall( - (:SCIPcopyProb, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Cuint, - Ptr{Cchar}, - ), - sourcescip, - targetscip, - varmap, - consmap, - _global, - name, - ) +function SCIPgetConsSignedPermsymGraph(scip, cons, graph, success) + ccall((:SCIPgetConsSignedPermsymGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SYM_GRAPH}, Ptr{Cuint}), scip, cons, graph, success) end -function SCIPcopyOrigProb(sourcescip, targetscip, varmap, consmap, name) - ccall( - (:SCIPcopyOrigProb, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Ptr{Cchar}, - ), - sourcescip, - targetscip, - varmap, - consmap, - name, - ) +function SCIPcopyPlugins(sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copyiisfinders, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, passmessagehdlr, valid) + ccall((:SCIPcopyPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copyiisfinders, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, passmessagehdlr, valid) end -function SCIPenableConsCompression(scip) - ccall( - (:SCIPenableConsCompression, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPcopyBenders(sourcescip, targetscip, varmap, threadsafe, valid) + ccall((:SCIPcopyBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, threadsafe, 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}, Cuint, Ptr{Cchar}), 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}, Ptr{Cchar}), sourcescip, targetscip, varmap, consmap, name) +end + +function SCIPenableConsCompression(scip) + ccall((:SCIPenableConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPisConsCompressionEnabled(scip) ccall((:SCIPisConsCompressionEnabled, libscip), Cuint, (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}, - Cuint, - Ptr{Cuint}, - ), - 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, - Cuint, - ), - 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, - ) +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}, Cuint, Ptr{Cuint}), 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, Cuint), 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 SCIPmergeNLPIStatistics(sourcescip, targetscip, reset) - ccall( - (:SCIPmergeNLPIStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP}, Cuint), - sourcescip, - targetscip, - reset, - ) + ccall((:SCIPmergeNLPIStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP}, Cuint), sourcescip, targetscip, reset) end function SCIPtranslateSubSol(scip, subscip, subsol, heur, subvars, newsol) - ccall( - (:SCIPtranslateSubSol, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_SOL}, - Ptr{SCIP_HEUR}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Ptr{SCIP_SOL}}, - ), - scip, - subscip, - subsol, - heur, - subvars, - newsol, - ) + ccall((:SCIPtranslateSubSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_SOL}}), scip, subscip, subsol, heur, subvars, newsol) end function SCIPtranslateSubSols(scip, subscip, heur, subvars, success, solindex) - ccall( - (:SCIPtranslateSubSols, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_HEUR}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cuint}, - Ptr{Cint}, - ), - scip, - subscip, - heur, - subvars, - success, - solindex, - ) -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}, - Ptr{Cchar}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - 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}, - Cuint, - Cuint, - Ptr{Cuint}, - ), - 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}, - Cuint, - Ptr{Cuint}, - ), - sourcescip, - targetscip, - varmap, - consmap, - enablepricing, - valid, - ) + ccall((:SCIPtranslateSubSols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}, Ptr{Cint}), scip, subscip, heur, subvars, success, solindex) +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}, Ptr{Cchar}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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}, Cuint, Cuint, Ptr{Cuint}), 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}, Cuint, Ptr{Cuint}), 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}, Cuint, 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}, - Cuint, - 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}, - Cuint, - Cuint, - Ptr{Cuint}, - ), - 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}, - Cuint, - Ptr{Cuint}, - Ptr{Cint}, - Ptr{Cint}, - ), - sourcescip, - targetscip, - varmap, - consmap, - _global, - infeasible, - nbdchgs, - ncopied, - ) + ccall((:SCIPconvertCutsToConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cuint, 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}, Cuint, 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}, Cuint, Cuint, Ptr{Cuint}), 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}, Cuint, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, infeasible, nbdchgs, ncopied) end function SCIPcopyParamSettings(sourcescip, targetscip) - ccall( - (:SCIPcopyParamSettings, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP}), - sourcescip, - targetscip, - ) + ccall((:SCIPcopyParamSettings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}), sourcescip, targetscip) end function SCIPgetSubscipDepth(scip) @@ -7986,343 +4822,75 @@ function SCIPgetSubscipDepth(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, - threadsafe, - passmessagehdlr, - valid, -) - ccall( - (:SCIPcopy, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Ptr{Cchar}, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - sourcescip, - targetscip, - varmap, - consmap, - suffix, - _global, - enablepricing, - threadsafe, - passmessagehdlr, - valid, - ) -end - -function SCIPcopyConsCompression( - sourcescip, - targetscip, - varmap, - consmap, - suffix, - fixedvars, - fixedvals, - nfixedvars, - _global, - enablepricing, - threadsafe, - passmessagehdlr, - valid, -) - ccall( - (:SCIPcopyConsCompression, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - sourcescip, - targetscip, - varmap, - consmap, - suffix, - fixedvars, - fixedvals, - nfixedvars, - _global, - enablepricing, - threadsafe, - passmessagehdlr, - valid, - ) -end - -function SCIPcopyOrig( - sourcescip, - targetscip, - varmap, - consmap, - suffix, - enablepricing, - threadsafe, - passmessagehdlr, - valid, -) - ccall( - (:SCIPcopyOrig, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Ptr{Cchar}, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - sourcescip, - targetscip, - varmap, - consmap, - suffix, - enablepricing, - threadsafe, - passmessagehdlr, - valid, - ) -end - -function SCIPcopyOrigConsCompression( - sourcescip, - targetscip, - varmap, - consmap, - suffix, - fixedvars, - fixedvals, - nfixedvars, - enablepricing, - threadsafe, - passmessagehdlr, - valid, -) - ccall( - (:SCIPcopyOrigConsCompression, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - sourcescip, - targetscip, - varmap, - consmap, - suffix, - fixedvars, - fixedvals, - nfixedvars, - enablepricing, - threadsafe, - passmessagehdlr, - valid, - ) + ccall((:SCIPsetSubscipDepth, libscip), Cvoid, (Ptr{SCIP}, Cint), scip, newdepth) +end + +function SCIPcopy(sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, threadsafe, passmessagehdlr, valid) + ccall((:SCIPcopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, threadsafe, passmessagehdlr, valid) +end + +function SCIPcopyConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, threadsafe, passmessagehdlr, valid) + ccall((:SCIPcopyConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, threadsafe, passmessagehdlr, valid) +end + +function SCIPcopyOrig(sourcescip, targetscip, varmap, consmap, suffix, enablepricing, threadsafe, passmessagehdlr, valid) + ccall((:SCIPcopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, suffix, enablepricing, threadsafe, passmessagehdlr, valid) +end + +function SCIPcopyOrigConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, threadsafe, passmessagehdlr, valid) + ccall((:SCIPcopyOrigConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, threadsafe, passmessagehdlr, valid) end function SCIPcheckCopyLimits(sourcescip, success) - ccall( - (:SCIPcheckCopyLimits, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cuint}), - sourcescip, - success, - ) + ccall((:SCIPcheckCopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), sourcescip, success) end function SCIPcopyLimits(sourcescip, targetscip) - ccall( - (:SCIPcopyLimits, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP}), - sourcescip, - targetscip, - ) -end - -function SCIPsetCommonSubscipParams( - sourcescip, - subscip, - nsubnodes, - nstallnodes, - bestsollimit, -) - ccall( - (:SCIPsetCommonSubscipParams, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP}, Clonglong, Clonglong, Cint), - sourcescip, - subscip, - nsubnodes, - nstallnodes, - bestsollimit, - ) + ccall((:SCIPcopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}), sourcescip, targetscip) +end + +function SCIPsetCommonSubscipParams(sourcescip, subscip, nsubnodes, nstallnodes, bestsollimit) + ccall((:SCIPsetCommonSubscipParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Clonglong, Clonglong, Cint), sourcescip, subscip, nsubnodes, nstallnodes, bestsollimit) end function SCIPgetCutLPSolCutoffDistance(scip, sol, cut) - ccall( - (:SCIPgetCutLPSolCutoffDistance, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), - scip, - sol, - cut, - ) + ccall((:SCIPgetCutLPSolCutoffDistance, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) end function SCIPgetCutEfficacy(scip, sol, cut) - ccall( - (:SCIPgetCutEfficacy, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), - scip, - sol, - cut, - ) + ccall((:SCIPgetCutEfficacy, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) end function SCIPisCutEfficacious(scip, sol, cut) - ccall( - (:SCIPisCutEfficacious, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), - scip, - sol, - cut, - ) + ccall((:SCIPisCutEfficacious, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) end function SCIPisEfficacious(scip, efficacy) - ccall( - (:SCIPisEfficacious, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - efficacy, - ) + ccall((:SCIPisEfficacious, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, efficacy) end function SCIPgetVectorEfficacyNorm(scip, vals, nvals) - ccall( - (:SCIPgetVectorEfficacyNorm, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{Cdouble}, Cint), - scip, - vals, - nvals, - ) + ccall((:SCIPgetVectorEfficacyNorm, libscip), Cdouble, (Ptr{SCIP}, Ptr{Cdouble}, Cint), scip, vals, nvals) end function SCIPisCutApplicable(scip, cut) - ccall( - (:SCIPisCutApplicable, libscip), - Cuint, - (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}, Cuint, Ptr{Cuint}), - scip, - sol, - cut, - forcecut, - infeasible, - ) + ccall((:SCIPisCutApplicable, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, cut) end function SCIPaddRow(scip, row, forcecut, infeasible) - ccall( - (:SCIPaddRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Cuint, Ptr{Cuint}), - scip, - row, - forcecut, - infeasible, - ) + ccall((:SCIPaddRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cuint, Ptr{Cuint}), scip, row, forcecut, infeasible) end function SCIPisCutNew(scip, row) - ccall( - (:SCIPisCutNew, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPisCutNew, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPaddPoolCut(scip, row) - ccall( - (:SCIPaddPoolCut, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPaddPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPdelPoolCut(scip, row) - ccall( - (:SCIPdelPoolCut, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPdelPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetPoolCuts(scip) @@ -8334,119 +4902,47 @@ function SCIPgetNPoolCuts(scip) end function SCIPgetGlobalCutpool(scip) - ccall( - (:SCIPgetGlobalCutpool, libscip), - Ptr{SCIP_CUTPOOL}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP},), scip) end function SCIPcreateCutpool(scip, cutpool, agelimit) - ccall( - (:SCIPcreateCutpool, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}, Cint), - scip, - cutpool, - agelimit, - ) + ccall((:SCIPcreateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}, Cint), scip, cutpool, agelimit) end function SCIPfreeCutpool(scip, cutpool) - ccall( - (:SCIPfreeCutpool, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}), - scip, - cutpool, - ) + ccall((:SCIPfreeCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}), scip, cutpool) end function SCIPaddRowCutpool(scip, cutpool, row) - ccall( - (:SCIPaddRowCutpool, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), - scip, - cutpool, - row, - ) + ccall((:SCIPaddRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) end function SCIPaddNewRowCutpool(scip, cutpool, row) - ccall( - (:SCIPaddNewRowCutpool, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), - scip, - cutpool, - row, - ) + ccall((:SCIPaddNewRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) end function SCIPdelRowCutpool(scip, cutpool, row) - ccall( - (:SCIPdelRowCutpool, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), - scip, - cutpool, - row, - ) + ccall((:SCIPdelRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) end function SCIPseparateCutpool(scip, cutpool, result) - ccall( - (:SCIPseparateCutpool, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_RESULT}), - scip, - cutpool, - result, - ) + ccall((:SCIPseparateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_RESULT}), scip, cutpool, result) end function SCIPseparateSolCutpool(scip, cutpool, sol, pretendroot, result) - ccall( - (:SCIPseparateSolCutpool, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_RESULT}), - scip, - cutpool, - sol, - pretendroot, - result, - ) + ccall((:SCIPseparateSolCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_RESULT}), scip, cutpool, sol, pretendroot, result) end function SCIPaddDelayedPoolCut(scip, row) - ccall( - (:SCIPaddDelayedPoolCut, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPaddDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPdelDelayedPoolCut(scip, row) - ccall( - (:SCIPdelDelayedPoolCut, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPdelDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetDelayedPoolCuts(scip) - ccall( - (:SCIPgetDelayedPoolCuts, libscip), - Ptr{Ptr{SCIP_CUT}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetDelayedPoolCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP},), scip) end function SCIPgetNDelayedPoolCuts(scip) @@ -8454,35 +4950,11 @@ function SCIPgetNDelayedPoolCuts(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}, Cuint, Cuint, Cuint, Ptr{Cuint}, Ptr{Cuint}), - scip, - sol, - pretendroot, - allowlocal, - onlydelayed, - delayed, - cutoff, - ) + 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}, Cuint, Cuint, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, sol, pretendroot, allowlocal, onlydelayed, delayed, cutoff) end function SCIPgetCuts(scip) @@ -8498,419 +4970,159 @@ function SCIPclearCuts(scip) end function SCIPremoveInefficaciousCuts(scip) - ccall( - (:SCIPremoveInefficaciousCuts, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPremoveInefficaciousCuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPcreateRealarray(scip, realarray) - ccall( - (:SCIPcreateRealarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), - scip, - realarray, - ) + ccall((:SCIPcreateRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) end function SCIPfreeRealarray(scip, realarray) - ccall( - (:SCIPfreeRealarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), - scip, - realarray, - ) + ccall((:SCIPfreeRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) end function SCIPextendRealarray(scip, realarray, minidx, maxidx) - ccall( - (:SCIPextendRealarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cint), - scip, - realarray, - minidx, - maxidx, - ) + ccall((:SCIPextendRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cint), scip, realarray, minidx, maxidx) end function SCIPclearRealarray(scip, realarray) - ccall( - (:SCIPclearRealarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), - scip, - realarray, - ) + ccall((:SCIPclearRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) end function SCIPgetRealarrayVal(scip, realarray, idx) - ccall( - (:SCIPgetRealarrayVal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint), - scip, - realarray, - idx, - ) + ccall((:SCIPgetRealarrayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint), scip, realarray, idx) end function SCIPsetRealarrayVal(scip, realarray, idx, val) - ccall( - (:SCIPsetRealarrayVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), - scip, - realarray, - idx, - val, - ) + ccall((:SCIPsetRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, val) end function SCIPincRealarrayVal(scip, realarray, idx, incval) - ccall( - (:SCIPincRealarrayVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), - scip, - realarray, - idx, - incval, - ) + ccall((:SCIPincRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, incval) end function SCIPgetRealarrayMinIdx(scip, realarray) - ccall( - (:SCIPgetRealarrayMinIdx, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), - scip, - realarray, - ) + ccall((:SCIPgetRealarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) end function SCIPgetRealarrayMaxIdx(scip, realarray) - ccall( - (:SCIPgetRealarrayMaxIdx, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), - scip, - realarray, - ) + ccall((:SCIPgetRealarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) end function SCIPcreateIntarray(scip, intarray) - ccall( - (:SCIPcreateIntarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), - scip, - intarray, - ) + ccall((:SCIPcreateIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) end function SCIPfreeIntarray(scip, intarray) - ccall( - (:SCIPfreeIntarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), - scip, - intarray, - ) + ccall((:SCIPfreeIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) end function SCIPextendIntarray(scip, intarray, minidx, maxidx) - ccall( - (:SCIPextendIntarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), - scip, - intarray, - minidx, - maxidx, - ) + ccall((:SCIPextendIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, minidx, maxidx) end function SCIPclearIntarray(scip, intarray) - ccall( - (:SCIPclearIntarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), - scip, - intarray, - ) + ccall((:SCIPclearIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) end function SCIPgetIntarrayVal(scip, intarray, idx) - ccall( - (:SCIPgetIntarrayVal, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint), - scip, - intarray, - idx, - ) + ccall((:SCIPgetIntarrayVal, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint), scip, intarray, idx) end function SCIPsetIntarrayVal(scip, intarray, idx, val) - ccall( - (:SCIPsetIntarrayVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), - scip, - intarray, - idx, - val, - ) + ccall((:SCIPsetIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, val) end function SCIPincIntarrayVal(scip, intarray, idx, incval) - ccall( - (:SCIPincIntarrayVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), - scip, - intarray, - idx, - incval, - ) + ccall((:SCIPincIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, incval) end function SCIPgetIntarrayMinIdx(scip, intarray) - ccall( - (:SCIPgetIntarrayMinIdx, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), - scip, - intarray, - ) + ccall((:SCIPgetIntarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) end function SCIPgetIntarrayMaxIdx(scip, intarray) - ccall( - (:SCIPgetIntarrayMaxIdx, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), - scip, - intarray, - ) + ccall((:SCIPgetIntarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) end function SCIPcreateBoolarray(scip, boolarray) - ccall( - (:SCIPcreateBoolarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), - scip, - boolarray, - ) + ccall((:SCIPcreateBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) end function SCIPfreeBoolarray(scip, boolarray) - ccall( - (:SCIPfreeBoolarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), - scip, - boolarray, - ) + ccall((:SCIPfreeBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) end function SCIPextendBoolarray(scip, boolarray, minidx, maxidx) - ccall( - (:SCIPextendBoolarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cint), - scip, - boolarray, - minidx, - maxidx, - ) + ccall((:SCIPextendBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cint), scip, boolarray, minidx, maxidx) end function SCIPclearBoolarray(scip, boolarray) - ccall( - (:SCIPclearBoolarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), - scip, - boolarray, - ) + ccall((:SCIPclearBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) end function SCIPgetBoolarrayVal(scip, boolarray, idx) - ccall( - (:SCIPgetBoolarrayVal, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint), - scip, - boolarray, - idx, - ) + ccall((:SCIPgetBoolarrayVal, libscip), Cuint, (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, Cuint), - scip, - boolarray, - idx, - val, - ) + ccall((:SCIPsetBoolarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cuint), scip, boolarray, idx, val) end function SCIPgetBoolarrayMinIdx(scip, boolarray) - ccall( - (:SCIPgetBoolarrayMinIdx, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), - scip, - boolarray, - ) + ccall((:SCIPgetBoolarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) end function SCIPgetBoolarrayMaxIdx(scip, boolarray) - ccall( - (:SCIPgetBoolarrayMaxIdx, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), - scip, - boolarray, - ) + ccall((:SCIPgetBoolarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) end function SCIPcreatePtrarray(scip, ptrarray) - ccall( - (:SCIPcreatePtrarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), - scip, - ptrarray, - ) + ccall((:SCIPcreatePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) end function SCIPfreePtrarray(scip, ptrarray) - ccall( - (:SCIPfreePtrarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), - scip, - ptrarray, - ) + ccall((:SCIPfreePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) end function SCIPextendPtrarray(scip, ptrarray, minidx, maxidx) - ccall( - (:SCIPextendPtrarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Cint), - scip, - ptrarray, - minidx, - maxidx, - ) + ccall((:SCIPextendPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Cint), scip, ptrarray, minidx, maxidx) end function SCIPclearPtrarray(scip, ptrarray) - ccall( - (:SCIPclearPtrarray, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), - scip, - ptrarray, - ) + ccall((:SCIPclearPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) end function SCIPgetPtrarrayVal(scip, ptrarray, idx) - ccall( - (:SCIPgetPtrarrayVal, libscip), - Ptr{Cvoid}, - (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint), - scip, - ptrarray, - idx, - ) + ccall((:SCIPgetPtrarrayVal, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint), scip, ptrarray, idx) end function SCIPsetPtrarrayVal(scip, ptrarray, idx, val) - ccall( - (:SCIPsetPtrarrayVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Ptr{Cvoid}), - scip, - ptrarray, - idx, - val, - ) + ccall((:SCIPsetPtrarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Ptr{Cvoid}), scip, ptrarray, idx, val) end function SCIPgetPtrarrayMinIdx(scip, ptrarray) - ccall( - (:SCIPgetPtrarrayMinIdx, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), - scip, - ptrarray, - ) + ccall((:SCIPgetPtrarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) end function SCIPgetPtrarrayMaxIdx(scip, ptrarray) - ccall( - (:SCIPgetPtrarrayMaxIdx, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), - scip, - ptrarray, - ) + ccall((:SCIPgetPtrarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) end function SCIPcreateDisjointset(scip, djset, ncomponents) - ccall( - (:SCIPcreateDisjointset, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}, Cint), - scip, - djset, - ncomponents, - ) + ccall((:SCIPcreateDisjointset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}, Cint), scip, djset, ncomponents) end function SCIPfreeDisjointset(scip, djset) - ccall( - (:SCIPfreeDisjointset, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}), - scip, - djset, - ) + ccall((:SCIPfreeDisjointset, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}), scip, djset) end function SCIPcreateDigraph(scip, digraph, nnodes) - ccall( - (:SCIPcreateDigraph, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Cint), - scip, - digraph, - nnodes, - ) + ccall((:SCIPcreateDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Cint), scip, digraph, nnodes) end function SCIPcopyDigraph(scip, targetdigraph, sourcedigraph) - ccall( - (:SCIPcopyDigraph, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Ptr{SCIP_DIGRAPH}), - scip, - targetdigraph, - sourcedigraph, - ) + ccall((:SCIPcopyDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Ptr{SCIP_DIGRAPH}), scip, targetdigraph, sourcedigraph) end function SCIPenableDebugSol(scip) @@ -8922,188 +5134,59 @@ function SCIPdisableDebugSol(scip) end function SCIPcreateDecomp(scip, decomp, nblocks, original, benderslabels) - ccall( - (:SCIPcreateDecomp, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_DECOMP}}, Cint, Cuint, Cuint), - scip, - decomp, - nblocks, - original, - benderslabels, - ) + ccall((:SCIPcreateDecomp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DECOMP}}, Cint, Cuint, Cuint), scip, decomp, nblocks, original, benderslabels) end function SCIPfreeDecomp(scip, decomp) - ccall( - (:SCIPfreeDecomp, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{SCIP_DECOMP}}), - scip, - decomp, - ) + ccall((:SCIPfreeDecomp, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DECOMP}}), scip, decomp) end function SCIPaddDecomp(scip, decomp) - ccall( - (:SCIPaddDecomp, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DECOMP}), - scip, - decomp, - ) + ccall((:SCIPaddDecomp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}), scip, decomp) end function SCIPgetDecomps(scip, decomps, ndecomps, original) - ccall( - (:SCIPgetDecomps, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_DECOMP}}}, Ptr{Cint}, Cuint), - scip, - decomps, - ndecomps, - original, - ) + ccall((:SCIPgetDecomps, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_DECOMP}}}, Ptr{Cint}, Cuint), scip, decomps, ndecomps, original) end function SCIPhasConsOnlyLinkVars(scip, decomp, cons, hasonlylinkvars) - ccall( - (:SCIPhasConsOnlyLinkVars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{SCIP_CONS}, Ptr{Cuint}), - scip, - decomp, - cons, - hasonlylinkvars, - ) + ccall((:SCIPhasConsOnlyLinkVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, decomp, cons, hasonlylinkvars) end function SCIPcomputeDecompConsLabels(scip, decomp, conss, nconss) - ccall( - (:SCIPcomputeDecompConsLabels, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint), - scip, - decomp, - conss, - nconss, - ) + ccall((:SCIPcomputeDecompConsLabels, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint), scip, decomp, conss, nconss) end function SCIPcomputeDecompVarsLabels(scip, decomp, conss, nconss) - ccall( - (:SCIPcomputeDecompVarsLabels, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint), - scip, - decomp, - conss, - nconss, - ) + ccall((:SCIPcomputeDecompVarsLabels, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint), scip, decomp, conss, nconss) end function SCIPassignDecompLinkConss(scip, decomp, conss, nconss, nskipconss) - ccall( - (:SCIPassignDecompLinkConss, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{Cint}), - scip, - decomp, - conss, - nconss, - nskipconss, - ) + ccall((:SCIPassignDecompLinkConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{Cint}), scip, decomp, conss, nconss, nskipconss) end function SCIPcomputeDecompStats(scip, decomp, uselimits) - ccall( - (:SCIPcomputeDecompStats, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Cuint), - scip, - decomp, - uselimits, - ) -end - -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}, - Ptr{Cchar}, - Ptr{Cchar}, - Cuint, - Ptr{SCIP_DIALOGDATA}, - ), - scip, - dialog, - dialogcopy, - dialogexec, - dialogdesc, - dialogfree, - name, - desc, - issubmenu, - dialogdata, - ) + ccall((:SCIPcomputeDecompStats, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Cuint), scip, decomp, uselimits) +end + +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}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Ptr{SCIP_DIALOGDATA}), scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu, dialogdata) end function SCIPexistsDialog(scip, dialog) - ccall( - (:SCIPexistsDialog, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_DIALOG}), - scip, - dialog, - ) + ccall((:SCIPexistsDialog, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) end function SCIPcaptureDialog(scip, dialog) - ccall( - (:SCIPcaptureDialog, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DIALOG}), - scip, - dialog, - ) + ccall((:SCIPcaptureDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) end function SCIPreleaseDialog(scip, dialog) - ccall( - (:SCIPreleaseDialog, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), - scip, - dialog, - ) + ccall((:SCIPreleaseDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog) end function SCIPsetRootDialog(scip, dialog) - ccall( - (:SCIPsetRootDialog, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DIALOG}), - scip, - dialog, - ) + ccall((:SCIPsetRootDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) end function SCIPgetRootDialog(scip) @@ -9111,109 +5194,27 @@ function SCIPgetRootDialog(scip) end function SCIPaddDialogEntry(scip, dialog, subdialog) - ccall( - (:SCIPaddDialogEntry, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOG}), - scip, - dialog, - subdialog, - ) + ccall((:SCIPaddDialogEntry, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOG}), scip, dialog, subdialog) end function SCIPaddDialogInputLine(scip, inputline) - ccall( - (:SCIPaddDialogInputLine, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - inputline, - ) + ccall((:SCIPaddDialogInputLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, inputline) end function SCIPaddDialogHistoryLine(scip, inputline) - ccall( - (:SCIPaddDialogHistoryLine, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - inputline, - ) + ccall((:SCIPaddDialogHistoryLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, inputline) end function SCIPstartInteraction(scip) ccall((:SCIPstartInteraction, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -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}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cchar}, - SCIP_DISPSTATUS, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_DISPDATA}, - Cint, - Cint, - Cint, - Cuint, - ), - scip, - name, - desc, - header, - dispstatus, - dispcopy, - dispfree, - dispinit, - dispexit, - dispinitsol, - dispexitsol, - dispoutput, - dispdata, - width, - priority, - position, - stripline, - ) +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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, SCIP_DISPSTATUS, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_DISPDATA}, Cint, Cint, Cint, Cuint), 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}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindDisp, libscip), Ptr{SCIP_DISP}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetDisps(scip) @@ -9229,183 +5230,51 @@ function SCIPautoselectDisps(scip) end function SCIPchgDispMode(disp, mode) - ccall( - (:SCIPchgDispMode, libscip), - Cvoid, - (Ptr{SCIP_DISP}, SCIP_DISPMODE), - disp, - mode, - ) -end - -function SCIPincludeEventhdlr( - scip, - name, - desc, - eventcopy, - eventfree, - eventinit, - eventexit, - eventinitsol, - eventexitsol, - eventdelete, - eventexec, - eventhdlrdata, -) - ccall( - (:SCIPincludeEventhdlr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cvoid}, - Ptr{SCIP_EVENTHDLRDATA}, - ), - scip, - eventhdlrptr, - name, - desc, - eventexec, - eventhdlrdata, - ) + ccall((:SCIPchgDispMode, libscip), Cvoid, (Ptr{SCIP_DISP}, SCIP_DISPMODE), disp, mode) +end + +function SCIPincludeEventhdlr(scip, name, desc, eventcopy, eventfree, eventinit, eventexit, eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata) + ccall((:SCIPincludeEventhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cvoid}, Ptr{SCIP_EVENTHDLRDATA}), scip, eventhdlrptr, name, desc, eventexec, eventhdlrdata) end function SCIPsetEventhdlrCopy(scip, eventhdlr, eventcopy) - ccall( - (:SCIPsetEventhdlrCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), - scip, - eventhdlr, - eventcopy, - ) + ccall((:SCIPsetEventhdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventcopy) end function SCIPsetEventhdlrFree(scip, eventhdlr, eventfree) - ccall( - (:SCIPsetEventhdlrFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), - scip, - eventhdlr, - eventfree, - ) + ccall((:SCIPsetEventhdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventfree) end function SCIPsetEventhdlrInit(scip, eventhdlr, eventinit) - ccall( - (:SCIPsetEventhdlrInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), - scip, - eventhdlr, - eventinit, - ) + ccall((:SCIPsetEventhdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinit) end function SCIPsetEventhdlrExit(scip, eventhdlr, eventexit) - ccall( - (:SCIPsetEventhdlrExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), - scip, - eventhdlr, - eventexit, - ) + ccall((:SCIPsetEventhdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexit) end function SCIPsetEventhdlrInitsol(scip, eventhdlr, eventinitsol) - ccall( - (:SCIPsetEventhdlrInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), - scip, - eventhdlr, - eventinitsol, - ) + ccall((:SCIPsetEventhdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinitsol) end function SCIPsetEventhdlrExitsol(scip, eventhdlr, eventexitsol) - ccall( - (:SCIPsetEventhdlrExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), - scip, - eventhdlr, - eventexitsol, - ) + ccall((:SCIPsetEventhdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexitsol) end function SCIPsetEventhdlrDelete(scip, eventhdlr, eventdelete) - ccall( - (:SCIPsetEventhdlrDelete, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), - scip, - eventhdlr, - eventdelete, - ) + ccall((:SCIPsetEventhdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventdelete) end function SCIPfindEventhdlr(scip, name) - ccall( - (:SCIPfindEventhdlr, libscip), - Ptr{SCIP_EVENTHDLR}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindEventhdlr, libscip), Ptr{SCIP_EVENTHDLR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetEventhdlrs(scip) - ccall( - (:SCIPgetEventhdlrs, libscip), - Ptr{Ptr{SCIP_EVENTHDLR}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetEventhdlrs, libscip), Ptr{Ptr{SCIP_EVENTHDLR}}, (Ptr{SCIP},), scip) end function SCIPgetNEventhdlrs(scip) @@ -9413,171 +5282,55 @@ function SCIPgetNEventhdlrs(scip) end function SCIPcatchEvent(scip, eventtype, eventhdlr, eventdata, filterpos) - ccall( - (:SCIPcatchEvent, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - SCIP_EVENTTYPE, - Ptr{SCIP_EVENTHDLR}, - Ptr{SCIP_EVENTDATA}, - Ptr{Cint}, - ), - scip, - eventtype, - eventhdlr, - eventdata, - filterpos, - ) + ccall((:SCIPcatchEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, eventtype, eventhdlr, eventdata, filterpos) end function SCIPdropEvent(scip, eventtype, eventhdlr, eventdata, filterpos) - ccall( - (:SCIPdropEvent, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - SCIP_EVENTTYPE, - Ptr{SCIP_EVENTHDLR}, - Ptr{SCIP_EVENTDATA}, - Cint, - ), - scip, - eventtype, - eventhdlr, - eventdata, - filterpos, - ) -end - -function SCIPcatchVarEvent( - scip, - var, - eventtype, - eventhdlr, - eventdata, - filterpos, -) - ccall( - (:SCIPcatchVarEvent, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - SCIP_EVENTTYPE, - Ptr{SCIP_EVENTHDLR}, - Ptr{SCIP_EVENTDATA}, - Ptr{Cint}, - ), - scip, - var, - eventtype, - eventhdlr, - eventdata, - filterpos, - ) + ccall((: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, - ) + 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, - ) + 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 + +function SCIPenableExactSolving(scip, enable) + ccall((:SCIPenableExactSolving, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, enable) +end + +function SCIPisExact(scip) + ccall((:SCIPisExact, libscip), Cuint, (Ptr{SCIP},), scip) +end + +function SCIPallowNegSlack(scip) + ccall((:SCIPallowNegSlack, libscip), Cuint, (Ptr{SCIP},), scip) +end + +function SCIPbranchLPExact(scip, result) + ccall((:SCIPbranchLPExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) +end + +function SCIPaddRowExact(scip, rowexact) + ccall((:SCIPaddRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}), scip, rowexact) end function SCIPincludeExprhdlr(scip, exprhdlr, name, desc, precedence, eval, data) - ccall( - (:SCIPincludeExprhdlr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPRHDLR}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cuint, - Ptr{Cvoid}, - Ptr{SCIP_EXPRHDLRDATA}, - ), - scip, - exprhdlr, - name, - desc, - precedence, - eval, - data, - ) + ccall((:SCIPincludeExprhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRHDLR}}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Ptr{Cvoid}, Ptr{SCIP_EXPRHDLRDATA}), scip, exprhdlr, name, desc, precedence, eval, data) end function SCIPgetExprhdlrs(scip) - ccall( - (:SCIPgetExprhdlrs, libscip), - Ptr{Ptr{SCIP_EXPRHDLR}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetExprhdlrs, libscip), Ptr{Ptr{SCIP_EXPRHDLR}}, (Ptr{SCIP},), scip) end function SCIPgetNExprhdlrs(scip) @@ -9585,357 +5338,71 @@ function SCIPgetNExprhdlrs(scip) end function SCIPfindExprhdlr(scip, name) - ccall( - (:SCIPfindExprhdlr, libscip), - Ptr{SCIP_EXPRHDLR}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindExprhdlr, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetExprhdlrVar(scip) - ccall( - (:SCIPgetExprhdlrVar, libscip), - Ptr{SCIP_EXPRHDLR}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetExprhdlrVar, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) end function SCIPgetExprhdlrValue(scip) - ccall( - (:SCIPgetExprhdlrValue, libscip), - Ptr{SCIP_EXPRHDLR}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetExprhdlrValue, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) end function SCIPgetExprhdlrSum(scip) - ccall( - (:SCIPgetExprhdlrSum, libscip), - Ptr{SCIP_EXPRHDLR}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetExprhdlrSum, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) end function SCIPgetExprhdlrProduct(scip) - ccall( - (:SCIPgetExprhdlrProduct, libscip), - Ptr{SCIP_EXPRHDLR}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetExprhdlrProduct, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) end function SCIPgetExprhdlrPower(scip) - ccall( - (:SCIPgetExprhdlrPower, libscip), - Ptr{SCIP_EXPRHDLR}, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPcreateExpr( - scip, - expr, - exprhdlr, - exprdata, - nchildren, - children, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcreateExpr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPRHDLR}, - Ptr{SCIP_EXPRDATA}, - Cint, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - exprhdlr, - exprdata, - nchildren, - children, - ownercreate, - ownercreatedata, - ) -end - -function SCIPcreateExpr2( - scip, - expr, - exprhdlr, - exprdata, - child1, - child2, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcreateExpr2, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPRHDLR}, - Ptr{SCIP_EXPRDATA}, - Ptr{SCIP_EXPR}, - Ptr{SCIP_EXPR}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - exprhdlr, - exprdata, - child1, - child2, - ownercreate, - ownercreatedata, - ) -end - -function SCIPcreateExprQuadratic( - scip, - expr, - nlinvars, - linvars, - lincoefs, - nquadterms, - quadvars1, - quadvars2, - quadcoefs, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcreateExprQuadratic, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - nlinvars, - linvars, - lincoefs, - nquadterms, - quadvars1, - quadvars2, - quadcoefs, - ownercreate, - ownercreatedata, - ) -end - -function SCIPcreateExprMonomial( - scip, - expr, - nfactors, - vars, - exponents, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcreateExprMonomial, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - nfactors, - vars, - exponents, - ownercreate, - ownercreatedata, - ) + ccall((:SCIPgetExprhdlrPower, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) +end + +function SCIPcreateExpr(scip, expr, exprhdlr, exprdata, nchildren, children, ownercreate, ownercreatedata) + ccall((:SCIPcreateExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPRHDLR}, Ptr{SCIP_EXPRDATA}, Cint, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, exprhdlr, exprdata, nchildren, children, ownercreate, ownercreatedata) +end + +function SCIPcreateExpr2(scip, expr, exprhdlr, exprdata, child1, child2, ownercreate, ownercreatedata) + ccall((:SCIPcreateExpr2, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPRHDLR}, Ptr{SCIP_EXPRDATA}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, exprhdlr, exprdata, child1, child2, ownercreate, ownercreatedata) +end + +function SCIPcreateExprQuadratic(scip, expr, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, ownercreate, ownercreatedata) +end + +function SCIPcreateExprMonomial(scip, expr, nfactors, vars, exponents, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprMonomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, nfactors, vars, exponents, ownercreate, ownercreatedata) end function SCIPappendExprChild(scip, expr, child) - ccall( - (:SCIPappendExprChild, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}), - scip, - expr, - child, - ) + ccall((:SCIPappendExprChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}), scip, expr, child) end function SCIPreplaceExprChild(scip, expr, childidx, newchild) - ccall( - (:SCIPreplaceExprChild, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cint, Ptr{SCIP_EXPR}), - scip, - expr, - childidx, - newchild, - ) + ccall((:SCIPreplaceExprChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cint, Ptr{SCIP_EXPR}), scip, expr, childidx, newchild) end function SCIPremoveExprChildren(scip, expr) - ccall( - (:SCIPremoveExprChildren, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) -end - -function SCIPduplicateExpr( - scip, - expr, - copyexpr, - mapexpr, - mapexprdata, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPduplicateExpr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - copyexpr, - mapexpr, - mapexprdata, - ownercreate, - ownercreatedata, - ) -end - -function SCIPduplicateExprShallow( - scip, - expr, - copyexpr, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPduplicateExprShallow, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - copyexpr, - ownercreate, - ownercreatedata, - ) -end - -function SCIPcopyExpr( - sourcescip, - targetscip, - expr, - copyexpr, - ownercreate, - ownercreatedata, - varmap, - consmap, - _global, - valid, -) - ccall( - (:SCIPcopyExpr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Cuint, - Ptr{Cuint}, - ), - sourcescip, - targetscip, - expr, - copyexpr, - ownercreate, - ownercreatedata, - varmap, - consmap, - _global, - valid, - ) -end - -function SCIPparseExpr( - scip, - expr, - exprstr, - finalpos, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPparseExpr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cchar}, - Ptr{Ptr{Cchar}}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - exprstr, - finalpos, - ownercreate, - ownercreatedata, - ) + ccall((:SCIPremoveExprChildren, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPduplicateExpr(scip, expr, copyexpr, mapexpr, mapexprdata, ownercreate, ownercreatedata) + ccall((:SCIPduplicateExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, copyexpr, mapexpr, mapexprdata, ownercreate, ownercreatedata) +end + +function SCIPduplicateExprShallow(scip, expr, copyexpr, ownercreate, ownercreatedata) + ccall((:SCIPduplicateExprShallow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, copyexpr, ownercreate, ownercreatedata) +end + +function SCIPcopyExpr(sourcescip, targetscip, expr, copyexpr, ownercreate, ownercreatedata, varmap, consmap, _global, valid) + ccall((:SCIPcopyExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cuint, Ptr{Cuint}), sourcescip, targetscip, expr, copyexpr, ownercreate, ownercreatedata, varmap, consmap, _global, valid) +end + +function SCIPparseExpr(scip, expr, exprstr, finalpos, ownercreate, ownercreatedata) + ccall((:SCIPparseExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, exprstr, finalpos, ownercreate, ownercreatedata) end function SCIPcaptureExpr(expr) @@ -9943,162 +5410,59 @@ function SCIPcaptureExpr(expr) end function SCIPreleaseExpr(scip, expr) - ccall( - (:SCIPreleaseExpr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}), - scip, - expr, - ) + ccall((:SCIPreleaseExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}), scip, expr) end function SCIPisExprVar(scip, expr) - ccall( - (:SCIPisExprVar, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPisExprVar, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPisExprValue(scip, expr) - ccall( - (:SCIPisExprValue, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPisExprValue, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPisExprSum(scip, expr) - ccall( - (:SCIPisExprSum, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPisExprSum, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPisExprProduct(scip, expr) - ccall( - (:SCIPisExprProduct, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPisExprProduct, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPisExprPower(scip, expr) - ccall( - (:SCIPisExprPower, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPisExprPower, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPprintExpr(scip, expr, file) - ccall( - (:SCIPprintExpr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Libc.FILE}), - scip, - expr, - file, - ) + ccall((:SCIPprintExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Libc.FILE}), scip, expr, file) end function SCIPprintExprDotInit(scip, printdata, file, whattoprint) - ccall( - (:SCIPprintExprDotInit, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPRPRINTDATA}}, - Ptr{Libc.FILE}, - SCIP_EXPRPRINT_WHAT, - ), - scip, - printdata, - file, - whattoprint, - ) + ccall((:SCIPprintExprDotInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRPRINTDATA}}, Ptr{Libc.FILE}, SCIP_EXPRPRINT_WHAT), scip, printdata, file, whattoprint) end function SCIPprintExprDotInit2(scip, printdata, filename, whattoprint) - ccall( - (:SCIPprintExprDotInit2, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPRPRINTDATA}}, - Ptr{Cchar}, - SCIP_EXPRPRINT_WHAT, - ), - scip, - printdata, - filename, - whattoprint, - ) + ccall((:SCIPprintExprDotInit2, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRPRINTDATA}}, Ptr{Cchar}, SCIP_EXPRPRINT_WHAT), scip, printdata, filename, whattoprint) end function SCIPprintExprDot(scip, printdata, expr) - ccall( - (:SCIPprintExprDot, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPRPRINTDATA}, Ptr{SCIP_EXPR}), - scip, - printdata, - expr, - ) + ccall((:SCIPprintExprDot, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRPRINTDATA}, Ptr{SCIP_EXPR}), scip, printdata, expr) end function SCIPprintExprDotFinal(scip, printdata) - ccall( - (:SCIPprintExprDotFinal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRPRINTDATA}}), - scip, - printdata, - ) + ccall((:SCIPprintExprDotFinal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRPRINTDATA}}), scip, printdata) end function SCIPshowExpr(scip, expr) - ccall( - (:SCIPshowExpr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPshowExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPdismantleExpr(scip, file, expr) - ccall( - (:SCIPdismantleExpr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_EXPR}), - scip, - file, - expr, - ) + ccall((:SCIPdismantleExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_EXPR}), scip, file, expr) end function SCIPevalExpr(scip, expr, sol, soltag) - ccall( - (:SCIPevalExpr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong), - scip, - expr, - sol, - soltag, - ) + ccall((:SCIPevalExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong), scip, expr, sol, soltag) end function SCIPgetExprNewSoltag(scip) @@ -10106,430 +5470,127 @@ function SCIPgetExprNewSoltag(scip) end function SCIPevalExprGradient(scip, expr, sol, soltag) - ccall( - (:SCIPevalExprGradient, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong), - scip, - expr, - sol, - soltag, - ) + ccall((:SCIPevalExprGradient, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong), scip, expr, sol, soltag) end function SCIPevalExprHessianDir(scip, expr, sol, soltag, direction) - ccall( - (:SCIPevalExprHessianDir, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong, Ptr{SCIP_SOL}), - scip, - expr, - sol, - soltag, - direction, - ) + ccall((:SCIPevalExprHessianDir, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong, Ptr{SCIP_SOL}), scip, expr, sol, soltag, direction) end function SCIPevalExprActivity(scip, expr) - ccall( - (:SCIPevalExprActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPevalExprActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPcompareExpr(scip, expr1, expr2) - ccall( - (:SCIPcompareExpr, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}), - scip, - expr1, - expr2, - ) + ccall((:SCIPcompareExpr, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}), scip, expr1, expr2) end function SCIPhashExpr(scip, expr, hashval) - ccall( - (:SCIPhashExpr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cuint}), - scip, - expr, - hashval, - ) -end - -function SCIPsimplifyExpr( - scip, - rootexpr, - simplified, - changed, - infeasible, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPsimplifyExpr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - rootexpr, - simplified, - changed, - infeasible, - ownercreate, - ownercreatedata, - ) + ccall((:SCIPhashExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cuint}), scip, expr, hashval) +end + +function SCIPsimplifyExpr(scip, rootexpr, simplified, changed, infeasible, ownercreate, ownercreatedata) + ccall((:SCIPsimplifyExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}), scip, rootexpr, simplified, changed, infeasible, ownercreate, ownercreatedata) +end + +function SCIPgetSymDataExpr(scip, expr, symdata) + ccall((:SCIPgetSymDataExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SYM_EXPRDATA}}), scip, expr, symdata) end function SCIPreplaceCommonSubexpressions(scip, exprs, nexprs, replacedroot) - ccall( - (:SCIPreplaceCommonSubexpressions, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Cuint}), - scip, - exprs, - nexprs, - replacedroot, - ) + ccall((:SCIPreplaceCommonSubexpressions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Cuint}), scip, exprs, nexprs, replacedroot) end function SCIPcomputeExprCurvature(scip, expr) - ccall( - (:SCIPcomputeExprCurvature, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPcomputeExprCurvature, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPcomputeExprIntegrality(scip, expr) - ccall( - (:SCIPcomputeExprIntegrality, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPcomputeExprIntegrality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPgetExprNVars(scip, expr, nvars) - ccall( - (:SCIPgetExprNVars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cint}), - scip, - expr, - nvars, - ) + ccall((:SCIPgetExprNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cint}), scip, expr, nvars) end function SCIPgetExprVarExprs(scip, expr, varexprs, nvarexprs) - ccall( - (:SCIPgetExprVarExprs, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cint}), - scip, - expr, - varexprs, - nvarexprs, - ) + ccall((:SCIPgetExprVarExprs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cint}), scip, expr, varexprs, nvarexprs) +end + +function SCIPcallExprPrint(scip, expr, stage, currentchild, parentprecedence, file) + ccall((:SCIPcallExprPrint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_STAGE, Cint, Cuint, Ptr{Libc.FILE}), scip, expr, stage, currentchild, parentprecedence, file) end function SCIPcallExprCurvature(scip, expr, exprcurvature, success, childcurv) - ccall( - (:SCIPcallExprCurvature, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - SCIP_EXPRCURV, - Ptr{Cuint}, - Ptr{SCIP_EXPRCURV}, - ), - scip, - expr, - exprcurvature, - success, - childcurv, - ) + ccall((:SCIPcallExprCurvature, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_EXPRCURV, Ptr{Cuint}, Ptr{SCIP_EXPRCURV}), scip, expr, exprcurvature, success, childcurv) end function SCIPcallExprMonotonicity(scip, expr, childidx, result) - ccall( - (:SCIPcallExprMonotonicity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cint, Ptr{SCIP_MONOTONE}), - scip, - expr, - childidx, - result, - ) + ccall((:SCIPcallExprMonotonicity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cint, Ptr{SCIP_MONOTONE}), scip, expr, childidx, result) end function SCIPcallExprEval(scip, expr, childrenvalues, val) - ccall( - (:SCIPcallExprEval, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cdouble}), - scip, - expr, - childrenvalues, - val, - ) + ccall((:SCIPcallExprEval, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cdouble}), scip, expr, childrenvalues, val) end function SCIPcallExprEvalFwdiff(scip, expr, childrenvalues, direction, val, dot) - ccall( - (:SCIPcallExprEvalFwdiff, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - scip, - expr, - childrenvalues, - direction, - val, - dot, - ) + ccall((:SCIPcallExprEvalFwdiff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), scip, expr, childrenvalues, direction, val, dot) end function SCIPcallExprInteval(scip, expr, interval, intevalvar, intevalvardata) - ccall( - (:SCIPcallExprInteval, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_INTERVAL}, Ptr{Cvoid}, Ptr{Cvoid}), - scip, - expr, - interval, - intevalvar, - intevalvardata, - ) -end - -function SCIPcallExprEstimate( - scip, - expr, - localbounds, - globalbounds, - refpoint, - overestimate, - targetvalue, - coefs, - constant, - islocal, - success, - branchcand, -) - ccall( - (:SCIPcallExprEstimate, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{SCIP_INTERVAL}, - Ptr{SCIP_INTERVAL}, - Ptr{Cdouble}, - Cuint, - Cdouble, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - expr, - localbounds, - globalbounds, - refpoint, - overestimate, - targetvalue, - coefs, - constant, - islocal, - success, - branchcand, - ) -end - -function SCIPcallExprInitestimates( - scip, - expr, - bounds, - overestimate, - coefs, - constant, - nreturned, -) - ccall( - (:SCIPcallExprInitestimates, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{SCIP_INTERVAL}, - Cuint, - Ptr{Ptr{Cdouble}}, - Ptr{Cdouble}, - Ptr{Cint}, - ), - scip, - expr, - bounds, - overestimate, - coefs, - constant, - nreturned, - ) -end - -function SCIPcallExprSimplify( - scip, - expr, - simplifiedexpr, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcallExprSimplify, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - simplifiedexpr, - ownercreate, - ownercreatedata, - ) + ccall((:SCIPcallExprInteval, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_INTERVAL}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, interval, intevalvar, intevalvardata) +end + +function SCIPcallExprEstimate(scip, expr, localbounds, globalbounds, refpoint, overestimate, targetvalue, coefs, constant, islocal, success, branchcand) + ccall((:SCIPcallExprEstimate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_INTERVAL}, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}, Cuint, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, expr, localbounds, globalbounds, refpoint, overestimate, targetvalue, coefs, constant, islocal, success, branchcand) +end + +function SCIPcallExprInitestimates(scip, expr, bounds, overestimate, coefs, constant, nreturned) + ccall((:SCIPcallExprInitestimates, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_INTERVAL}, Cuint, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}), scip, expr, bounds, overestimate, coefs, constant, nreturned) +end + +function SCIPcallExprSimplify(scip, expr, simplifiedexpr, ownercreate, ownercreatedata) + ccall((:SCIPcallExprSimplify, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, simplifiedexpr, ownercreate, ownercreatedata) end function SCIPcallExprReverseprop(scip, expr, bounds, childrenbounds, infeasible) - ccall( - (:SCIPcallExprReverseprop, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - SCIP_INTERVAL, - Ptr{SCIP_INTERVAL}, - Ptr{Cuint}, - ), - scip, - expr, - bounds, - childrenbounds, - infeasible, - ) + ccall((:SCIPcallExprReverseprop, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_INTERVAL, Ptr{SCIP_INTERVAL}, Ptr{Cuint}), scip, expr, bounds, childrenbounds, infeasible) +end + +function SCIPcallExprGetSymData(scip, expr, symdata) + ccall((:SCIPcallExprGetSymData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SYM_EXPRDATA}}), scip, expr, symdata) end function SCIPcreateExpriter(scip, iterator) - ccall( - (:SCIPcreateExpriter, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRITER}}), - scip, - iterator, - ) + ccall((:SCIPcreateExpriter, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRITER}}), scip, iterator) end function SCIPfreeExpriter(iterator) - ccall( - (:SCIPfreeExpriter, libscip), - Cvoid, - (Ptr{Ptr{SCIP_EXPRITER}},), - iterator, - ) + ccall((:SCIPfreeExpriter, libscip), Cvoid, (Ptr{Ptr{SCIP_EXPRITER}},), iterator) end function SCIPcheckExprQuadratic(scip, expr, isquadratic) - ccall( - (:SCIPcheckExprQuadratic, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cuint}), - scip, - expr, - isquadratic, - ) + ccall((:SCIPcheckExprQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cuint}), scip, expr, isquadratic) end function SCIPfreeExprQuadratic(scip, expr) - ccall( - (:SCIPfreeExprQuadratic, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) + ccall((:SCIPfreeExprQuadratic, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) end function SCIPevalExprQuadratic(scip, expr, sol) - ccall( - (:SCIPevalExprQuadratic, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}), - scip, - expr, - sol, - ) + ccall((:SCIPevalExprQuadratic, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}), scip, expr, sol) end function SCIPprintExprQuadratic(scip, expr) - ccall( - (:SCIPprintExprQuadratic, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) -end - -function SCIPcomputeExprQuadraticCurvature( - scip, - expr, - curv, - assumevarfixed, - storeeigeninfo, -) - ccall( - (:SCIPcomputeExprQuadraticCurvature, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{SCIP_EXPRCURV}, - Ptr{SCIP_HASHMAP}, - Cuint, - ), - scip, - expr, - curv, - assumevarfixed, - storeeigeninfo, - ) + ccall((:SCIPprintExprQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPcomputeExprQuadraticCurvature(scip, expr, curv, assumevarfixed, storeeigeninfo) + ccall((:SCIPcomputeExprQuadraticCurvature, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPRCURV}, Ptr{SCIP_HASHMAP}, Cuint), scip, expr, curv, assumevarfixed, storeeigeninfo) +end + +function SCIPgetExprMonomialData(scip, expr, coef, exponents, factors) + ccall((:SCIPgetExprMonomialData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{SCIP_EXPR}}), scip, expr, coef, exponents, factors) end function SCIPversion() @@ -10553,23 +5614,11 @@ function SCIPsubversion() end function SCIPprintVersion(scip, file) - ccall( - (:SCIPprintVersion, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintVersion, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) end function SCIPprintBuildOptions(scip, file) - ccall( - (:SCIPprintBuildOptions, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintBuildOptions, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) end function SCIPprintError(retcode) @@ -10589,37 +5638,25 @@ function SCIPgetStage(scip) end function SCIPprintStage(scip, file) - ccall( - (:SCIPprintStage, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintStage, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) end function SCIPgetStatus(scip) ccall((:SCIPgetStatus, libscip), SCIP_STATUS, (Ptr{SCIP},), scip) end +function SCIPstatusName(status) + ccall((:SCIPstatusName, libscip), Ptr{Cchar}, (SCIP_STATUS,), status) +end + function SCIPprintStatus(scip, file) - ccall( - (:SCIPprintStatus, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintStatus, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) end function SCIPisTransformed(scip) ccall((:SCIPisTransformed, libscip), Cuint, (Ptr{SCIP},), scip) end -function SCIPisExactSolve(scip) - ccall((:SCIPisExactSolve, libscip), Cuint, (Ptr{SCIP},), scip) -end - function SCIPisPresolveFinished(scip) ccall((:SCIPisPresolveFinished, libscip), Cuint, (Ptr{SCIP},), scip) end @@ -10637,32 +5674,15 @@ function SCIPisStopped(scip) end function SCIPincludeExternalCodeInformation(scip, name, description) - ccall( - (:SCIPincludeExternalCodeInformation, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), - scip, - name, - description, - ) + ccall((:SCIPincludeExternalCodeInformation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, name, description) end function SCIPgetExternalCodeNames(scip) - ccall( - (:SCIPgetExternalCodeNames, libscip), - Ptr{Ptr{Cchar}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetExternalCodeNames, libscip), Ptr{Ptr{Cchar}}, (Ptr{SCIP},), scip) end function SCIPgetExternalCodeDescriptions(scip) - ccall( - (:SCIPgetExternalCodeDescriptions, libscip), - Ptr{Ptr{Cchar}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetExternalCodeDescriptions, libscip), Ptr{Ptr{Cchar}}, (Ptr{SCIP},), scip) end function SCIPgetNExternalCodes(scip) @@ -10670,202 +5690,43 @@ function SCIPgetNExternalCodes(scip) end function SCIPprintExternalCodes(scip, file) - ccall( - (:SCIPprintExternalCodes, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) -end - -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}, - Ptr{Cchar}, - Ptr{Cchar}, - Cchar, - Cint, - Cint, - Cint, - Cint, - SCIP_HEURTIMING, - Cuint, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cchar, - Cint, - Cint, - Cint, - Cint, - SCIP_HEURTIMING, - Cuint, - Ptr{Cvoid}, - Ptr{SCIP_HEURDATA}, - ), - scip, - heur, - name, - desc, - dispchar, - priority, - freq, - freqofs, - maxdepth, - timingmask, - usessubscip, - heurexec, - heurdata, - ) + ccall((:SCIPprintExternalCodes, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +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}, Ptr{Cchar}, Ptr{Cchar}, Cchar, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cchar, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, Cuint, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, heur, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurexec, heurdata) end function SCIPsetHeurCopy(scip, heur, heurcopy) - ccall( - (:SCIPsetHeurCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), - scip, - heur, - heurcopy, - ) + ccall((:SCIPsetHeurCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurcopy) end function SCIPsetHeurFree(scip, heur, heurfree) - ccall( - (:SCIPsetHeurFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), - scip, - heur, - heurfree, - ) + ccall((:SCIPsetHeurFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurfree) end function SCIPsetHeurInit(scip, heur, heurinit) - ccall( - (:SCIPsetHeurInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), - scip, - heur, - heurinit, - ) + ccall((:SCIPsetHeurInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinit) end function SCIPsetHeurExit(scip, heur, heurexit) - ccall( - (:SCIPsetHeurExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), - scip, - heur, - heurexit, - ) + ccall((:SCIPsetHeurExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexit) end function SCIPsetHeurInitsol(scip, heur, heurinitsol) - ccall( - (:SCIPsetHeurInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), - scip, - heur, - heurinitsol, - ) + ccall((:SCIPsetHeurInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinitsol) end function SCIPsetHeurExitsol(scip, heur, heurexitsol) - ccall( - (:SCIPsetHeurExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), - scip, - heur, - heurexitsol, - ) + ccall((:SCIPsetHeurExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexitsol) end function SCIPfindHeur(scip, name) - ccall( - (:SCIPfindHeur, libscip), - Ptr{SCIP_HEUR}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetHeurs(scip) @@ -10877,98 +5738,55 @@ function SCIPgetNHeurs(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, - ispublic, - specificsos1score, - divesetgetscore, - divesetavailable, -) - ccall( - (:SCIPcreateDiveset, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_DIVESET}}, - Ptr{SCIP_HEUR}, - Ptr{Cchar}, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cint, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - diveset, - heur, - name, - minreldepth, - maxreldepth, - maxlpiterquot, - maxdiveubquot, - maxdiveavgquot, - maxdiveubquotnosol, - maxdiveavgquotnosol, - lpresolvedomchgquot, - lpsolvefreq, - maxlpiterofs, - initialseed, - backtrack, - onlylpbranchcands, - ispublic, - specificsos1score, - divesetgetscore, - divesetavailable, - ) + 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, ispublic, specificsos1score, divesetgetscore, divesetavailable) + ccall((:SCIPcreateDiveset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIVESET}}, Ptr{SCIP_HEUR}, Ptr{Cchar}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}), scip, diveset, heur, name, minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol, maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack, onlylpbranchcands, ispublic, specificsos1score, divesetgetscore, divesetavailable) end function SCIPisDivesetAvailable(scip, diveset, available) - ccall( - (:SCIPisDivesetAvailable, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{Cuint}), - scip, - diveset, - available, - ) + ccall((:SCIPisDivesetAvailable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{Cuint}), scip, diveset, available) +end + +function SCIPincludeIISfinder(scip, name, desc, priority, iisfindercopy, iisfinderfree, iisfinderexec, iisfinderdata) + ccall((:SCIPincludeIISfinder, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_IISFINDERDATA}), scip, name, desc, priority, iisfindercopy, iisfinderfree, iisfinderexec, iisfinderdata) +end + +function SCIPincludeIISfinderBasic(scip, iisfinder, name, desc, priority, iisfinderexec, iisfinderdata) + ccall((:SCIPincludeIISfinderBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_IISFINDER}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{SCIP_IISFINDERDATA}), scip, iisfinder, name, desc, priority, iisfinderexec, iisfinderdata) +end + +function SCIPsetIISfinderCopy(scip, iisfinder, iisfindercopy) + ccall((:SCIPsetIISfinderCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Ptr{Cvoid}), scip, iisfinder, iisfindercopy) +end + +function SCIPsetIISfinderFree(scip, iisfinder, iisfinderfree) + ccall((:SCIPsetIISfinderFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Ptr{Cvoid}), scip, iisfinder, iisfinderfree) +end + +function SCIPgenerateIIS(scip) + ccall((:SCIPgenerateIIS, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPfindIISfinder(scip, name) + ccall((:SCIPfindIISfinder, libscip), Ptr{SCIP_IISFINDER}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) +end + +function SCIPgetIISfinders(scip) + ccall((:SCIPgetIISfinders, libscip), Ptr{Ptr{SCIP_IISFINDER}}, (Ptr{SCIP},), scip) +end + +function SCIPgetNIISfinders(scip) + ccall((:SCIPgetNIISfinders, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPsetIISfinderPriority(scip, iisfinder, priority) + ccall((:SCIPsetIISfinderPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Cint), scip, iisfinder, priority) +end + +function SCIPgetIIS(scip) + ccall((:SCIPgetIIS, libscip), Ptr{SCIP_IIS}, (Ptr{SCIP},), scip) end function SCIPhasCurrentNodeLP(scip) @@ -10980,13 +5798,7 @@ function SCIPisLPConstructed(scip) end function SCIPconstructLP(scip, cutoff) - ccall( - (:SCIPconstructLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cuint}), - scip, - cutoff, - ) + ccall((:SCIPconstructLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, cutoff) end function SCIPflushLP(scip) @@ -11050,13 +5862,7 @@ function SCIPgetLPFeastol(scip) end function SCIPsetLPFeastol(scip, newfeastol) - ccall( - (:SCIPsetLPFeastol, libscip), - Cvoid, - (Ptr{SCIP}, Cdouble), - scip, - newfeastol, - ) + ccall((:SCIPsetLPFeastol, libscip), Cvoid, (Ptr{SCIP}, Cdouble), scip, newfeastol) end function SCIPresetLPFeastol(scip) @@ -11064,14 +5870,7 @@ function SCIPresetLPFeastol(scip) end function SCIPgetLPColsData(scip, cols, ncols) - ccall( - (:SCIPgetLPColsData, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_COL}}}, Ptr{Cint}), - scip, - cols, - ncols, - ) + ccall((:SCIPgetLPColsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_COL}}}, Ptr{Cint}), scip, cols, ncols) end function SCIPgetLPCols(scip) @@ -11087,14 +5886,7 @@ function SCIPgetNUnfixedLPCols(scip) end function SCIPgetLPRowsData(scip, rows, nrows) - ccall( - (:SCIPgetLPRowsData, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_ROW}}}, Ptr{Cint}), - scip, - rows, - nrows, - ) + ccall((:SCIPgetLPRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_ROW}}}, Ptr{Cint}), scip, rows, nrows) end function SCIPgetLPRows(scip) @@ -11114,960 +5906,219 @@ function SCIPisLPSolBasic(scip) end function SCIPgetLPBasisInd(scip, basisind) - ccall( - (:SCIPgetLPBasisInd, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cint}), - scip, - basisind, - ) + ccall((:SCIPgetLPBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, basisind) end function SCIPgetLPBInvRow(scip, r, coefs, inds, ninds) - ccall( - (:SCIPgetLPBInvRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), - scip, - r, - coefs, - inds, - ninds, - ) + ccall((:SCIPgetLPBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, coefs, inds, ninds) end function SCIPgetLPBInvCol(scip, c, coefs, inds, ninds) - ccall( - (:SCIPgetLPBInvCol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), - scip, - c, - coefs, - inds, - ninds, - ) + ccall((:SCIPgetLPBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) end function SCIPgetLPBInvARow(scip, r, binvrow, coefs, inds, ninds) - ccall( - (:SCIPgetLPBInvARow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), - scip, - r, - binvrow, - coefs, - inds, - ninds, - ) + ccall((:SCIPgetLPBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, binvrow, coefs, inds, ninds) end function SCIPgetLPBInvACol(scip, c, coefs, inds, ninds) - ccall( - (:SCIPgetLPBInvACol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), - scip, - c, - coefs, - inds, - ninds, - ) + ccall((:SCIPgetLPBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) end function SCIPsumLPRows(scip, weights, sumcoef, sumlhs, sumrhs) - ccall( - (:SCIPsumLPRows, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cdouble}, - Ptr{SCIP_REALARRAY}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - scip, - weights, - sumcoef, - sumlhs, - sumrhs, - ) + ccall((:SCIPsumLPRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}, Ptr{SCIP_REALARRAY}, Ptr{Cdouble}, Ptr{Cdouble}), scip, weights, sumcoef, sumlhs, sumrhs) end function SCIPinterruptLP(scip, interrupt) - ccall( - (:SCIPinterruptLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint), - scip, - interrupt, - ) + ccall((:SCIPinterruptLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, interrupt) end function SCIPwriteLP(scip, filename) - ccall( - (:SCIPwriteLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - filename, - ) + ccall((:SCIPwriteLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) end function SCIPwriteMIP(scip, filename, genericnames, origobj, lazyconss) - ccall( - (:SCIPwriteMIP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Cuint, Cuint, Cuint), - scip, - filename, - genericnames, - origobj, - lazyconss, - ) + ccall((:SCIPwriteMIP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cuint, Cuint, Cuint), scip, filename, genericnames, origobj, lazyconss) end -const SCIP_LPi = Cvoid - -const SCIP_LPI = SCIP_LPi - function SCIPgetLPI(scip, lpi) - ccall( - (:SCIPgetLPI, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_LPI}}), - scip, - lpi, - ) + ccall((:SCIPgetLPI, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LPI}}), scip, lpi) end function SCIPprintLPSolutionQuality(scip, file) - ccall( - (:SCIPprintLPSolutionQuality, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) -end - -function SCIPcomputeLPRelIntPoint( - scip, - relaxrows, - inclobjcutoff, - timelimit, - iterlimit, - point, -) - ccall( - (:SCIPcomputeLPRelIntPoint, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint, Cuint, Cdouble, Cint, Ptr{Ptr{SCIP_SOL}}), - scip, - relaxrows, - inclobjcutoff, - timelimit, - iterlimit, - point, - ) + ccall((:SCIPprintLPSolutionQuality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcomputeLPRelIntPoint(scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) + ccall((:SCIPcomputeLPRelIntPoint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Cuint, Cdouble, Cint, Ptr{Ptr{SCIP_SOL}}), scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) end function SCIPgetColRedcost(scip, col) - ccall( - (:SCIPgetColRedcost, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_COL}), - scip, - col, - ) + ccall((:SCIPgetColRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) end function SCIPgetColFarkasCoef(scip, col) - ccall( - (:SCIPgetColFarkasCoef, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_COL}), - scip, - col, - ) + ccall((:SCIPgetColFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) end function SCIPmarkColNotRemovableLocal(scip, col) - ccall( - (:SCIPmarkColNotRemovableLocal, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_COL}), - scip, - col, - ) -end - -function SCIPcreateRowConshdlr( - scip, - row, - conshdlr, - name, - len, - cols, - vals, - lhs, - rhs, - _local, - modifiable, - removable, -) - ccall( - (:SCIPcreateRowConshdlr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_ROW}}, - Ptr{SCIP_CONSHDLR}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_COL}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - scip, - row, - conshdlr, - name, - len, - cols, - vals, - lhs, - rhs, - _local, - modifiable, - removable, - ) -end - -function SCIPcreateRowCons( - scip, - row, - cons, - name, - len, - cols, - vals, - lhs, - rhs, - _local, - modifiable, - removable, -) - ccall( - (:SCIPcreateRowCons, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_ROW}}, - Ptr{SCIP_CONS}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_COL}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - scip, - row, - cons, - 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}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_COL}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_COL}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_COL}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - scip, - row, - name, - len, - cols, - vals, - lhs, - rhs, - _local, - modifiable, - removable, - ) -end - -function SCIPcreateEmptyRowConshdlr( - scip, - row, - conshdlr, - name, - lhs, - rhs, - _local, - modifiable, - removable, -) - ccall( - (:SCIPcreateEmptyRowConshdlr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_ROW}}, - Ptr{SCIP_CONSHDLR}, - Ptr{Cchar}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - scip, - row, - conshdlr, - name, - lhs, - rhs, - _local, - modifiable, - removable, - ) -end - -function SCIPcreateEmptyRowCons( - scip, - row, - cons, - name, - lhs, - rhs, - _local, - modifiable, - removable, -) - ccall( - (:SCIPcreateEmptyRowCons, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_ROW}}, - Ptr{SCIP_CONS}, - Ptr{Cchar}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - scip, - row, - cons, - 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}, - Ptr{Cchar}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - ), - scip, - row, - name, - lhs, - rhs, - _local, - modifiable, - removable, - ) + ccall((:SCIPmarkColNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) +end + +function SCIPcreateRowConshdlr(scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateRowConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateRowCons(scip, row, cons, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONS}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, cons, 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}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateEmptyRowConshdlr(scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateEmptyRowConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Ptr{Cchar}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) +end + +function SCIPcreateEmptyRowCons(scip, row, cons, name, lhs, rhs, _local, modifiable, removable) + ccall((:SCIPcreateEmptyRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONS}, Ptr{Cchar}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, cons, 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}, Ptr{Cchar}, Cdouble, Cdouble, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, name, lhs, rhs, _local, modifiable, removable) end function SCIPcaptureRow(scip, row) - ccall( - (:SCIPcaptureRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPcaptureRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPreleaseRow(scip, row) - ccall( - (:SCIPreleaseRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}), - scip, - row, - ) + ccall((:SCIPreleaseRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}), scip, row) end function SCIPchgRowLhs(scip, row, lhs) - ccall( - (:SCIPchgRowLhs, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), - scip, - row, - lhs, - ) + ccall((:SCIPchgRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, lhs) end function SCIPchgRowRhs(scip, row, rhs) - ccall( - (:SCIPchgRowRhs, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), - scip, - row, - rhs, - ) + ccall((:SCIPchgRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, rhs) end function SCIPcacheRowExtensions(scip, row) - ccall( - (:SCIPcacheRowExtensions, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPcacheRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPflushRowExtensions(scip, row) - ccall( - (:SCIPflushRowExtensions, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPflushRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPaddVarToRow(scip, row, var, val) - ccall( - (:SCIPaddVarToRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_VAR}, Cdouble), - scip, - row, - var, - val, - ) + ccall((:SCIPaddVarToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_VAR}, Cdouble), scip, row, var, val) end function SCIPaddVarsToRow(scip, row, nvars, vars, vals) - ccall( - (:SCIPaddVarsToRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), - scip, - row, - nvars, - vars, - vals, - ) + ccall((:SCIPaddVarsToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, row, nvars, vars, vals) end function SCIPaddVarsToRowSameCoef(scip, row, nvars, vars, val) - ccall( - (:SCIPaddVarsToRowSameCoef, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Cdouble), - scip, - row, - nvars, - vars, - val, - ) -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, - Cuint, - Ptr{Cdouble}, - Ptr{Cuint}, - ), - 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, - Cuint, - Ptr{Cuint}, - ), - scip, - row, - mindelta, - maxdelta, - maxdnom, - maxscale, - usecontvars, - success, - ) + 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, Cuint, Ptr{Cdouble}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) end function SCIPmarkRowNotRemovableLocal(scip, row) - ccall( - (:SCIPmarkRowNotRemovableLocal, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPmarkRowNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowNumIntCols(scip, row) - ccall( - (:SCIPgetRowNumIntCols, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowNumIntCols, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) +end + +function SCIPgetRowNumImpliedIntCols(scip, row) + ccall((:SCIPgetRowNumImpliedIntCols, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowMinCoef(scip, row) - ccall( - (:SCIPgetRowMinCoef, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowMinCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowMaxCoef(scip, row) - ccall( - (:SCIPgetRowMaxCoef, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowMaxCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowMinActivity(scip, row) - ccall( - (:SCIPgetRowMinActivity, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowMinActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowMaxActivity(scip, row) - ccall( - (:SCIPgetRowMaxActivity, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowMaxActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPrecalcRowLPActivity(scip, row) - ccall( - (:SCIPrecalcRowLPActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPrecalcRowLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowLPActivity(scip, row) - ccall( - (:SCIPgetRowLPActivity, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowLPActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowLPFeasibility(scip, row) - ccall( - (:SCIPgetRowLPFeasibility, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowLPFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPrecalcRowPseudoActivity(scip, row) - ccall( - (:SCIPrecalcRowPseudoActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPrecalcRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowPseudoActivity(scip, row) - ccall( - (:SCIPgetRowPseudoActivity, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowPseudoActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowPseudoFeasibility(scip, row) - ccall( - (:SCIPgetRowPseudoFeasibility, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowPseudoFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPrecalcRowActivity(scip, row) - ccall( - (:SCIPrecalcRowActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPrecalcRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowActivity(scip, row) - ccall( - (:SCIPgetRowActivity, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowFeasibility(scip, row) - ccall( - (:SCIPgetRowFeasibility, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPgetRowSolActivity(scip, row, sol) - ccall( - (:SCIPgetRowSolActivity, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), - scip, - row, - sol, - ) + ccall((:SCIPgetRowSolActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) end function SCIPgetRowSolFeasibility(scip, row, sol) - ccall( - (:SCIPgetRowSolFeasibility, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), - scip, - row, - sol, - ) + ccall((:SCIPgetRowSolFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) end function SCIPgetRowObjParallelism(scip, row) - ccall( - (:SCIPgetRowObjParallelism, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPgetRowObjParallelism, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPprintRow(scip, row, file) - ccall( - (:SCIPprintRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{Libc.FILE}), - scip, - row, - file, - ) + ccall((:SCIPprintRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{Libc.FILE}), scip, row, file) end function SCIPstartDive(scip) @@ -12079,120 +6130,47 @@ function SCIPendDive(scip) end function SCIPchgCutoffboundDive(scip, newcutoffbound) - ccall( - (:SCIPchgCutoffboundDive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - newcutoffbound, - ) + ccall((:SCIPchgCutoffboundDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newcutoffbound) end function SCIPchgVarObjDive(scip, var, newobj) - ccall( - (:SCIPchgVarObjDive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newobj, - ) + ccall((:SCIPchgVarObjDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end function SCIPchgVarLbDive(scip, var, newbound) - ccall( - (:SCIPchgVarLbDive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newbound, - ) + ccall((:SCIPchgVarLbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarUbDive(scip, var, newbound) - ccall( - (:SCIPchgVarUbDive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newbound, - ) + ccall((:SCIPchgVarUbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPaddRowDive(scip, row) - ccall( - (:SCIPaddRowDive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPaddRowDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPchgRowLhsDive(scip, row, newlhs) - ccall( - (:SCIPchgRowLhsDive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), - scip, - row, - newlhs, - ) + ccall((:SCIPchgRowLhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newlhs) end function SCIPchgRowRhsDive(scip, row, newrhs) - ccall( - (:SCIPchgRowRhsDive, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), - scip, - row, - newrhs, - ) + ccall((:SCIPchgRowRhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newrhs) end function SCIPgetVarObjDive(scip, var) - ccall( - (:SCIPgetVarObjDive, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarObjDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarLbDive(scip, var) - ccall( - (:SCIPgetVarLbDive, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarLbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarUbDive(scip, var) - ccall( - (:SCIPgetVarUbDive, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarUbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPsolveDiveLP(scip, itlim, lperror, cutoff) - ccall( - (:SCIPsolveDiveLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), - scip, - itlim, - lperror, - cutoff, - ) + ccall((:SCIPsolveDiveLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, itlim, lperror, cutoff) end function SCIPgetLastDivenode(scip) @@ -12204,14 +6182,7 @@ function SCIPinDive(scip) end function SCIPgetLPDualDegeneracy(scip, degeneracy, varconsratio) - ccall( - (:SCIPgetLPDualDegeneracy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cdouble}, Ptr{Cdouble}), - scip, - degeneracy, - varconsratio, - ) + ccall((:SCIPgetLPDualDegeneracy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}, Ptr{Cdouble}), scip, degeneracy, varconsratio) end function SCIPgetMemUsed(scip) @@ -12234,43 +6205,24 @@ function SCIPprintMemoryDiagnostic(scip) ccall((:SCIPprintMemoryDiagnostic, libscip), Cvoid, (Ptr{SCIP},), scip) end +function SCIPcollectMemoryGarbage(scip) + ccall((:SCIPcollectMemoryGarbage, libscip), Cvoid, (Ptr{SCIP},), scip) +end + function SCIPsetMessagehdlr(scip, messagehdlr) - ccall( - (:SCIPsetMessagehdlr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_MESSAGEHDLR}), - scip, - messagehdlr, - ) + ccall((:SCIPsetMessagehdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_MESSAGEHDLR}), scip, messagehdlr) end function SCIPgetMessagehdlr(scip) - ccall( - (:SCIPgetMessagehdlr, libscip), - Ptr{SCIP_MESSAGEHDLR}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetMessagehdlr, libscip), Ptr{SCIP_MESSAGEHDLR}, (Ptr{SCIP},), scip) end function SCIPsetMessagehdlrLogfile(scip, filename) - ccall( - (:SCIPsetMessagehdlrLogfile, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - filename, - ) + ccall((:SCIPsetMessagehdlrLogfile, libscip), Cvoid, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) end function SCIPsetMessagehdlrQuiet(scip, quiet) - ccall( - (:SCIPsetMessagehdlrQuiet, libscip), - Cvoid, - (Ptr{SCIP}, Cuint), - scip, - quiet, - ) + ccall((:SCIPsetMessagehdlrQuiet, libscip), Cvoid, (Ptr{SCIP}, Cuint), scip, quiet) end function SCIPgetVerbLevel(scip) @@ -12290,24 +6242,11 @@ function SCIPisNLPConstructed(scip) end function SCIPhasNLPContinuousNonlinearity(scip, result) - ccall( - (:SCIPhasNLPContinuousNonlinearity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cuint}), - scip, - result, - ) + ccall((:SCIPhasNLPContinuousNonlinearity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, result) end function SCIPgetNLPVarsData(scip, vars, nvars) - ccall( - (:SCIPgetNLPVarsData, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}), - scip, - vars, - nvars, - ) + ccall((:SCIPgetNLPVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}), scip, vars, nvars) end function SCIPgetNLPVars(scip) @@ -12319,13 +6258,7 @@ function SCIPgetNNLPVars(scip) end function SCIPgetNLPVarsNonlinearity(scip, nlcount) - ccall( - (:SCIPgetNLPVarsNonlinearity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cint}), - scip, - nlcount, - ) + ccall((:SCIPgetNLPVarsNonlinearity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, nlcount) end function SCIPgetNLPVarsLbDualsol(scip) @@ -12337,47 +6270,27 @@ function SCIPgetNLPVarsUbDualsol(scip) end function SCIPgetNLPNlRowsData(scip, nlrows, nnlrows) - ccall( - (:SCIPgetNLPNlRowsData, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NLROW}}}, Ptr{Cint}), - scip, - nlrows, - nnlrows, - ) + ccall((:SCIPgetNLPNlRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NLROW}}}, Ptr{Cint}), scip, nlrows, nnlrows) end function SCIPgetNLPNlRows(scip) - ccall( - (:SCIPgetNLPNlRows, libscip), - Ptr{Ptr{SCIP_NLROW}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNLPNlRows, libscip), Ptr{Ptr{SCIP_NLROW}}, (Ptr{SCIP},), scip) end function SCIPgetNNLPNlRows(scip) ccall((:SCIPgetNNLPNlRows, libscip), Cint, (Ptr{SCIP},), scip) end +function SCIPgetNLPNlRowsStat(scip, nlinear, nconvexineq, nnonconvexineq, nnonlineareq) + ccall((:SCIPgetNLPNlRowsStat, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, nlinear, nconvexineq, nnonconvexineq, nnonlineareq) +end + function SCIPaddNlRow(scip, nlrow) - ccall( - (:SCIPaddNlRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}), - scip, - nlrow, - ) + ccall((:SCIPaddNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPdelNlRow(scip, nlrow) - ccall( - (:SCIPdelNlRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}), - scip, - nlrow, - ) + ccall((:SCIPdelNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPflushNLP(scip) @@ -12385,23 +6298,11 @@ function SCIPflushNLP(scip) end function SCIPsetNLPInitialGuess(scip, initialguess) - ccall( - (:SCIPsetNLPInitialGuess, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cdouble}), - scip, - initialguess, - ) + ccall((:SCIPsetNLPInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}), scip, initialguess) end function SCIPsetNLPInitialGuessSol(scip, sol) - ccall( - (:SCIPsetNLPInitialGuessSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPsetNLPInitialGuessSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPgetNLPSolstat(scip) @@ -12413,13 +6314,7 @@ function SCIPgetNLPTermstat(scip) end function SCIPgetNLPStatistics(scip, statistics) - ccall( - (:SCIPgetNLPStatistics, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLPSTATISTICS}), - scip, - statistics, - ) + ccall((:SCIPgetNLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPSTATISTICS}), scip, statistics) end function SCIPgetNLPObjval(scip) @@ -12430,53 +6325,16 @@ function SCIPhasNLPSolution(scip) ccall((:SCIPhasNLPSolution, libscip), Cuint, (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, - ) +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 SCIPwriteNLP(scip, filename) - ccall( - (:SCIPwriteNLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - filename, - ) + ccall((:SCIPwriteNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) end function SCIPgetNLPI(scip, nlpi, nlpiproblem) - ccall( - (:SCIPgetNLPI, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_NLPI}}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), - scip, - nlpi, - nlpiproblem, - ) + ccall((:SCIPgetNLPI, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLPI}}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), scip, nlpi, nlpiproblem) end function SCIPstartDiveNLP(scip) @@ -12488,451 +6346,127 @@ function SCIPendDiveNLP(scip) end function SCIPchgVarObjDiveNLP(scip, var, coef) - ccall( - (:SCIPchgVarObjDiveNLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - coef, - ) + ccall((:SCIPchgVarObjDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, coef) end function SCIPchgVarBoundsDiveNLP(scip, var, lb, ub) - ccall( - (:SCIPchgVarBoundsDiveNLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), - scip, - var, - lb, - ub, - ) + ccall((:SCIPchgVarBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, lb, ub) end function SCIPchgVarsBoundsDiveNLP(scip, nvars, vars, lbs, ubs) - ccall( - (:SCIPchgVarsBoundsDiveNLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), - scip, - nvars, - vars, - lbs, - ubs, - ) -end - -function SCIPcreateNlRow( - scip, - nlrow, - name, - constant, - nlinvars, - linvars, - lincoefs, - expr, - lhs, - rhs, - curvature, -) - ccall( - (:SCIPcreateNlRow, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_NLROW}}, - Ptr{Cchar}, - Cdouble, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{SCIP_EXPR}, - Cdouble, - Cdouble, - SCIP_EXPRCURV, - ), - scip, - nlrow, - name, - constant, - nlinvars, - linvars, - lincoefs, - expr, - lhs, - rhs, - curvature, - ) + ccall((:SCIPchgVarsBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nvars, vars, lbs, ubs) +end + +function SCIPcreateNlRow(scip, nlrow, name, constant, nlinvars, linvars, lincoefs, expr, lhs, rhs, curvature) + ccall((:SCIPcreateNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{Cchar}, Cdouble, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_EXPR}, Cdouble, Cdouble, SCIP_EXPRCURV), scip, nlrow, name, constant, nlinvars, linvars, lincoefs, expr, lhs, rhs, curvature) end function SCIPcreateEmptyNlRow(scip, nlrow, name, lhs, rhs) - ccall( - (:SCIPcreateEmptyNlRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{Cchar}, Cdouble, Cdouble), - scip, - nlrow, - name, - lhs, - rhs, - ) + ccall((:SCIPcreateEmptyNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{Cchar}, Cdouble, Cdouble), scip, nlrow, name, lhs, rhs) end function SCIPcreateNlRowFromRow(scip, nlrow, row) - ccall( - (:SCIPcreateNlRowFromRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{SCIP_ROW}), - scip, - nlrow, - row, - ) + ccall((:SCIPcreateNlRowFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{SCIP_ROW}), scip, nlrow, row) end function SCIPcaptureNlRow(scip, nlrow) - ccall( - (:SCIPcaptureNlRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}), - scip, - nlrow, - ) + ccall((:SCIPcaptureNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPreleaseNlRow(scip, nlrow) - ccall( - (:SCIPreleaseNlRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}), - scip, - nlrow, - ) + ccall((:SCIPreleaseNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}), scip, nlrow) end function SCIPchgNlRowLhs(scip, nlrow, lhs) - ccall( - (:SCIPchgNlRowLhs, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), - scip, - nlrow, - lhs, - ) + ccall((:SCIPchgNlRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, lhs) end function SCIPchgNlRowRhs(scip, nlrow, rhs) - ccall( - (:SCIPchgNlRowRhs, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), - scip, - nlrow, - rhs, - ) + ccall((:SCIPchgNlRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, rhs) end function SCIPchgNlRowConstant(scip, nlrow, constant) - ccall( - (:SCIPchgNlRowConstant, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), - scip, - nlrow, - constant, - ) + ccall((:SCIPchgNlRowConstant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, constant) +end + +function SCIPsetNlRowCurvature(scip, nlrow, curvature) + ccall((:SCIPsetNlRowCurvature, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_EXPRCURV), scip, nlrow, curvature) end function SCIPaddLinearCoefToNlRow(scip, nlrow, var, val) - ccall( - (:SCIPaddLinearCoefToNlRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), - scip, - nlrow, - var, - val, - ) + ccall((:SCIPaddLinearCoefToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, val) end function SCIPaddLinearCoefsToNlRow(scip, nlrow, nvars, vars, vals) - ccall( - (:SCIPaddLinearCoefsToNlRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), - scip, - nlrow, - nvars, - vars, - vals, - ) + ccall((:SCIPaddLinearCoefsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nlrow, nvars, vars, vals) end function SCIPchgNlRowLinearCoef(scip, nlrow, var, coef) - ccall( - (:SCIPchgNlRowLinearCoef, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), - scip, - nlrow, - var, - coef, - ) + ccall((:SCIPchgNlRowLinearCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, coef) end function SCIPsetNlRowExpr(scip, nlrow, expr) - ccall( - (:SCIPsetNlRowExpr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_EXPR}), - scip, - nlrow, - expr, - ) + ccall((:SCIPsetNlRowExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_EXPR}), scip, nlrow, expr) end function SCIPrecalcNlRowNLPActivity(scip, nlrow) - ccall( - (:SCIPrecalcNlRowNLPActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}), - scip, - nlrow, - ) + ccall((:SCIPrecalcNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPgetNlRowNLPActivity(scip, nlrow, activity) - ccall( - (:SCIPgetNlRowNLPActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), - scip, - nlrow, - activity, - ) + ccall((:SCIPgetNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) end function SCIPgetNlRowNLPFeasibility(scip, nlrow, feasibility) - ccall( - (:SCIPgetNlRowNLPFeasibility, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), - scip, - nlrow, - feasibility, - ) + ccall((:SCIPgetNlRowNLPFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) end function SCIPrecalcNlRowPseudoActivity(scip, nlrow) - ccall( - (:SCIPrecalcNlRowPseudoActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}), - scip, - nlrow, - ) + ccall((:SCIPrecalcNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPgetNlRowPseudoActivity(scip, nlrow, pseudoactivity) - ccall( - (:SCIPgetNlRowPseudoActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), - scip, - nlrow, - pseudoactivity, - ) + ccall((:SCIPgetNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudoactivity) end function SCIPgetNlRowPseudoFeasibility(scip, nlrow, pseudofeasibility) - ccall( - (:SCIPgetNlRowPseudoFeasibility, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), - scip, - nlrow, - pseudofeasibility, - ) + ccall((:SCIPgetNlRowPseudoFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudofeasibility) end function SCIPrecalcNlRowActivity(scip, nlrow) - ccall( - (:SCIPrecalcNlRowActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}), - scip, - nlrow, - ) + ccall((:SCIPrecalcNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) end function SCIPgetNlRowActivity(scip, nlrow, activity) - ccall( - (:SCIPgetNlRowActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), - scip, - nlrow, - activity, - ) + ccall((:SCIPgetNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) end function SCIPgetNlRowFeasibility(scip, nlrow, feasibility) - ccall( - (:SCIPgetNlRowFeasibility, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), - scip, - nlrow, - feasibility, - ) + ccall((:SCIPgetNlRowFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) end function SCIPgetNlRowSolActivity(scip, nlrow, sol, activity) - ccall( - (:SCIPgetNlRowSolActivity, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), - scip, - nlrow, - sol, - activity, - ) + ccall((:SCIPgetNlRowSolActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, activity) end function SCIPgetNlRowSolFeasibility(scip, nlrow, sol, feasibility) - ccall( - (:SCIPgetNlRowSolFeasibility, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), - scip, - nlrow, - sol, - feasibility, - ) + ccall((:SCIPgetNlRowSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, feasibility) end function SCIPgetNlRowActivityBounds(scip, nlrow, minactivity, maxactivity) - ccall( - (:SCIPgetNlRowActivityBounds, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}, Ptr{Cdouble}), - scip, - nlrow, - minactivity, - maxactivity, - ) + ccall((:SCIPgetNlRowActivityBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlrow, minactivity, maxactivity) end function SCIPprintNlRow(scip, nlrow, file) - ccall( - (:SCIPprintNlRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Libc.FILE}), - scip, - nlrow, - file, - ) -end - -function SCIPincludeNlpi( - scip, - name, - description, - priority, - nlpicopy, - nlpifree, - nlpigetsolverpointer, - nlpicreateproblem, - nlpifreeproblem, - nlpigetproblempointer, - nlpiaddvars, - nlpiaddconstraints, - nlpisetobjective, - nlpichgvarbounds, - nlpichgconssides, - nlpidelvarset, - nlpidelconsset, - nlpichglinearcoefs, - nlpichgexpr, - nlpichgobjconstant, - nlpisetinitialguess, - nlpisolve, - nlpigetsolstat, - nlpigettermstat, - nlpigetsolution, - nlpigetstatistics, - nlpidata, -) - ccall( - (:SCIPincludeNlpi, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - 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_NLPIDATA}, - ), - scip, - name, - description, - priority, - nlpicopy, - nlpifree, - nlpigetsolverpointer, - nlpicreateproblem, - nlpifreeproblem, - nlpigetproblempointer, - nlpiaddvars, - nlpiaddconstraints, - nlpisetobjective, - nlpichgvarbounds, - nlpichgconssides, - nlpidelvarset, - nlpidelconsset, - nlpichglinearcoefs, - nlpichgexpr, - nlpichgobjconstant, - nlpisetinitialguess, - nlpisolve, - nlpigetsolstat, - nlpigettermstat, - nlpigetsolution, - nlpigetstatistics, - nlpidata, - ) + ccall((:SCIPprintNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Libc.FILE}), scip, nlrow, file) +end + +function SCIPincludeNlpi(scip, name, description, priority, nlpicopy, nlpifree, nlpigetsolverpointer, nlpicreateproblem, nlpifreeproblem, nlpigetproblempointer, nlpiaddvars, nlpiaddconstraints, nlpisetobjective, nlpichgvarbounds, nlpichgconssides, nlpidelvarset, nlpidelconsset, nlpichglinearcoefs, nlpichgexpr, nlpichgobjconstant, nlpisetinitialguess, nlpisolve, nlpigetsolstat, nlpigettermstat, nlpigetsolution, nlpigetstatistics, nlpidata) + ccall((:SCIPincludeNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, 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_NLPIDATA}), scip, name, description, priority, nlpicopy, nlpifree, nlpigetsolverpointer, nlpicreateproblem, nlpifreeproblem, nlpigetproblempointer, nlpiaddvars, nlpiaddconstraints, nlpisetobjective, nlpichgvarbounds, nlpichgconssides, nlpidelvarset, nlpidelconsset, nlpichglinearcoefs, nlpichgexpr, nlpichgobjconstant, nlpisetinitialguess, nlpisolve, nlpigetsolstat, nlpigettermstat, nlpigetsolution, nlpigetstatistics, nlpidata) end function SCIPfindNlpi(scip, name) - ccall( - (:SCIPfindNlpi, libscip), - Ptr{SCIP_NLPI}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindNlpi, libscip), Ptr{SCIP_NLPI}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetNlpis(scip) @@ -12944,689 +6478,139 @@ function SCIPgetNNlpis(scip) end function SCIPsetNlpiPriority(scip, nlpi, priority) - ccall( - (:SCIPsetNlpiPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Cint), - scip, - nlpi, - priority, - ) + ccall((:SCIPsetNlpiPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Cint), scip, nlpi, priority) end function SCIPgetNlpiSolverPointer(scip, nlpi, problem) - ccall( - (:SCIPgetNlpiSolverPointer, libscip), - Ptr{Cvoid}, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), - scip, - nlpi, - problem, - ) + ccall((:SCIPgetNlpiSolverPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), scip, nlpi, problem) end function SCIPcreateNlpiProblem(scip, nlpi, problem, name) - ccall( - (:SCIPcreateNlpiProblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}), - scip, - nlpi, - problem, - name, - ) + ccall((:SCIPcreateNlpiProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}), scip, nlpi, problem, name) end function SCIPfreeNlpiProblem(scip, nlpi, problem) - ccall( - (:SCIPfreeNlpiProblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), - scip, - nlpi, - problem, - ) + ccall((:SCIPfreeNlpiProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), scip, nlpi, problem) end function SCIPgetNlpiProblemPointer(scip, nlpi, problem) - ccall( - (:SCIPgetNlpiProblemPointer, libscip), - Ptr{Cvoid}, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), - scip, - nlpi, - problem, - ) + ccall((:SCIPgetNlpiProblemPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), scip, nlpi, problem) end function SCIPaddNlpiVars(scip, nlpi, problem, nvars, lbs, ubs, varnames) - ccall( - (:SCIPaddNlpiVars, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Ptr{Cchar}}, - ), - scip, - nlpi, - problem, - nvars, - lbs, - ubs, - varnames, - ) -end - -function SCIPaddNlpiConstraints( - scip, - nlpi, - problem, - nconss, - lhss, - rhss, - nlininds, - lininds, - linvals, - exprs, - names, -) - ccall( - (:SCIPaddNlpiConstraints, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Ptr{Cchar}}, - ), - scip, - nlpi, - problem, - nconss, - lhss, - rhss, - nlininds, - lininds, - linvals, - exprs, - names, - ) -end - -function SCIPsetNlpiObjective( - scip, - nlpi, - problem, - nlins, - lininds, - linvals, - expr, - constant, -) - ccall( - (:SCIPsetNlpiObjective, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{SCIP_EXPR}, - Cdouble, - ), - scip, - nlpi, - problem, - nlins, - lininds, - linvals, - expr, - constant, - ) + ccall((:SCIPaddNlpiVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), scip, nlpi, problem, nvars, lbs, ubs, varnames) +end + +function SCIPaddNlpiConstraints(scip, nlpi, problem, nconss, lhss, rhss, nlininds, lininds, linvals, exprs, names) + ccall((:SCIPaddNlpiConstraints, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Ptr{Cchar}}), scip, nlpi, problem, nconss, lhss, rhss, nlininds, lininds, linvals, exprs, names) +end + +function SCIPsetNlpiObjective(scip, nlpi, problem, nlins, lininds, linvals, expr, constant) + ccall((:SCIPsetNlpiObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_EXPR}, Cdouble), scip, nlpi, problem, nlins, lininds, linvals, expr, constant) end function SCIPchgNlpiVarBounds(scip, nlpi, problem, nvars, indices, lbs, ubs) - ccall( - (:SCIPchgNlpiVarBounds, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - scip, - nlpi, - problem, - nvars, - indices, - lbs, - ubs, - ) + ccall((:SCIPchgNlpiVarBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlpi, problem, nvars, indices, lbs, ubs) end function SCIPchgNlpiConsSides(scip, nlpi, problem, nconss, indices, lhss, rhss) - ccall( - (:SCIPchgNlpiConsSides, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - scip, - nlpi, - problem, - nconss, - indices, - lhss, - rhss, - ) + ccall((:SCIPchgNlpiConsSides, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlpi, problem, nconss, indices, lhss, rhss) end function SCIPdelNlpiVarSet(scip, nlpi, problem, dstats, dstatssize) - ccall( - (:SCIPdelNlpiVarSet, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), - scip, - nlpi, - problem, - dstats, - dstatssize, - ) + ccall((:SCIPdelNlpiVarSet, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), scip, nlpi, problem, dstats, dstatssize) end function SCIPdelNlpiConsSet(scip, nlpi, problem, dstats, dstatssize) - ccall( - (:SCIPdelNlpiConsSet, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), - scip, - nlpi, - problem, - dstats, - dstatssize, - ) + ccall((:SCIPdelNlpiConsSet, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), scip, nlpi, problem, dstats, dstatssize) end function SCIPchgNlpiLinearCoefs(scip, nlpi, problem, idx, nvals, varidxs, vals) - ccall( - (:SCIPchgNlpiLinearCoefs, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - ), - scip, - nlpi, - problem, - idx, - nvals, - varidxs, - vals, - ) + ccall((:SCIPchgNlpiLinearCoefs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Cint, Ptr{Cint}, Ptr{Cdouble}), scip, nlpi, problem, idx, nvals, varidxs, vals) end function SCIPchgNlpiExpr(scip, nlpi, problem, idxcons, expr) - ccall( - (:SCIPchgNlpiExpr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Cint, - Ptr{SCIP_EXPR}, - ), - scip, - nlpi, - problem, - idxcons, - expr, - ) + ccall((:SCIPchgNlpiExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{SCIP_EXPR}), scip, nlpi, problem, idxcons, expr) end function SCIPchgNlpiObjConstant(scip, nlpi, problem, objconstant) - ccall( - (:SCIPchgNlpiObjConstant, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cdouble), - scip, - nlpi, - problem, - objconstant, - ) -end - -function SCIPsetNlpiInitialGuess( - scip, - nlpi, - problem, - primalvalues, - consdualvalues, - varlbdualvalues, - varubdualvalues, -) - ccall( - (:SCIPsetNlpiInitialGuess, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - scip, - nlpi, - problem, - primalvalues, - consdualvalues, - varlbdualvalues, - varubdualvalues, - ) + ccall((:SCIPchgNlpiObjConstant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cdouble), scip, nlpi, problem, objconstant) +end + +function SCIPsetNlpiInitialGuess(scip, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues) + ccall((:SCIPsetNlpiInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues) end function SCIPgetNlpiSolstat(scip, nlpi, problem) - ccall( - (:SCIPgetNlpiSolstat, libscip), - SCIP_NLPSOLSTAT, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), - scip, - nlpi, - problem, - ) + ccall((:SCIPgetNlpiSolstat, libscip), SCIP_NLPSOLSTAT, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), scip, nlpi, problem) end function SCIPgetNlpiTermstat(scip, nlpi, problem) - ccall( - (:SCIPgetNlpiTermstat, libscip), - SCIP_NLPTERMSTAT, - (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), - scip, - nlpi, - problem, - ) -end - -function SCIPgetNlpiSolution( - scip, - nlpi, - problem, - primalvalues, - consdualvalues, - varlbdualvalues, - varubdualvalues, - objval, -) - ccall( - (:SCIPgetNlpiSolution, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Cdouble}, - ), - scip, - nlpi, - problem, - primalvalues, - consdualvalues, - varlbdualvalues, - varubdualvalues, - objval, - ) + ccall((:SCIPgetNlpiTermstat, libscip), SCIP_NLPTERMSTAT, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), scip, nlpi, problem) +end + +function SCIPgetNlpiSolution(scip, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) + ccall((:SCIPgetNlpiSolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}), scip, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) end function SCIPgetNlpiStatistics(scip, nlpi, problem, statistics) - ccall( - (:SCIPgetNlpiStatistics, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{SCIP_NLPSTATISTICS}, - ), - scip, - nlpi, - problem, - statistics, - ) -end - -function SCIPcreateNlpiProblemFromNlRows( - scip, - nlpi, - nlpiprob, - name, - nlrows, - nnlrows, - var2idx, - nlrow2idx, - nlscore, - cutoffbound, - setobj, - onlyconvex, -) - ccall( - (:SCIPcreateNlpiProblemFromNlRows, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{Ptr{SCIP_NLPIPROBLEM}}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_NLROW}}, - Cint, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Ptr{Cdouble}, - Cdouble, - Cuint, - Cuint, - ), - scip, - nlpi, - nlpiprob, - name, - nlrows, - nnlrows, - var2idx, - nlrow2idx, - nlscore, - cutoffbound, - setobj, - onlyconvex, - ) -end - -function SCIPupdateNlpiProblem( - scip, - nlpi, - nlpiprob, - var2nlpiidx, - nlpivars, - nlpinvars, - cutoffbound, -) - ccall( - (:SCIPupdateNlpiProblem, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{SCIP_HASHMAP}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cdouble, - ), - scip, - nlpi, - nlpiprob, - var2nlpiidx, - nlpivars, - nlpinvars, - cutoffbound, - ) + ccall((:SCIPgetNlpiStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_NLPSTATISTICS}), scip, nlpi, problem, statistics) +end + +function SCIPcreateNlpiProblemFromNlRows(scip, nlpi, nlpiprob, name, nlrows, nnlrows, var2idx, nlrow2idx, nlscore, cutoffbound, setobj, onlyconvex) + ccall((:SCIPcreateNlpiProblemFromNlRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}, Ptr{Ptr{SCIP_NLROW}}, Cint, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cdouble}, Cdouble, Cuint, Cuint), scip, nlpi, nlpiprob, name, nlrows, nnlrows, var2idx, nlrow2idx, nlscore, cutoffbound, setobj, onlyconvex) +end + +function SCIPupdateNlpiProblem(scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) + ccall((:SCIPupdateNlpiProblem, 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 SCIPaddNlpiProblemRows(scip, nlpi, nlpiprob, var2idx, rows, nrows) - ccall( - (:SCIPaddNlpiProblemRows, 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 - -function SCIPaddNlpiProblemNlRows( - scip, - nlpi, - nlpiprob, - var2idx, - nlrows, - nnlrows, -) - ccall( - (:SCIPaddNlpiProblemNlRows, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLPI}, - Ptr{SCIP_NLPIPROBLEM}, - Ptr{SCIP_HASHMAP}, - Ptr{Ptr{SCIP_NLROW}}, - Cint, - ), - scip, - nlpi, - nlpiprob, - var2idx, - nlrows, - nnlrows, - ) -end - -function SCIPincludeNodesel( - scip, - name, - desc, - stdpriority, - memsavepriority, - nodeselcopy, - nodeselfree, - nodeselinit, - nodeselexit, - nodeselinitsol, - nodeselexitsol, - nodeselselect, - nodeselcomp, - nodeseldata, -) - ccall( - (:SCIPincludeNodesel, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_NODESELDATA}, - ), - scip, - nodesel, - name, - desc, - stdpriority, - memsavepriority, - nodeselselect, - nodeselcomp, - nodeseldata, - ) + ccall((:SCIPaddNlpiProblemRows, 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 + +function SCIPaddNlpiProblemNlRows(scip, nlpi, nlpiprob, var2idx, nlrows, nnlrows) + ccall((:SCIPaddNlpiProblemNlRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_NLROW}}, Cint), scip, nlpi, nlpiprob, var2idx, nlrows, nnlrows) +end + +function SCIPincludeNodesel(scip, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) + ccall((:SCIPincludeNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, nodesel, name, desc, stdpriority, memsavepriority, nodeselselect, nodeselcomp, nodeseldata) end function SCIPsetNodeselCopy(scip, nodesel, nodeselcopy) - ccall( - (:SCIPsetNodeselCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), - scip, - nodesel, - nodeselcopy, - ) + ccall((:SCIPsetNodeselCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselcopy) end function SCIPsetNodeselFree(scip, nodesel, nodeselfree) - ccall( - (:SCIPsetNodeselFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), - scip, - nodesel, - nodeselfree, - ) + ccall((:SCIPsetNodeselFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselfree) end function SCIPsetNodeselInit(scip, nodesel, nodeselinit) - ccall( - (:SCIPsetNodeselInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), - scip, - nodesel, - nodeselinit, - ) + ccall((:SCIPsetNodeselInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinit) end function SCIPsetNodeselExit(scip, nodesel, nodeselexit) - ccall( - (:SCIPsetNodeselExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), - scip, - nodesel, - nodeselexit, - ) + ccall((:SCIPsetNodeselExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexit) end function SCIPsetNodeselInitsol(scip, nodesel, nodeselinitsol) - ccall( - (:SCIPsetNodeselInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), - scip, - nodesel, - nodeselinitsol, - ) + ccall((:SCIPsetNodeselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinitsol) end function SCIPsetNodeselExitsol(scip, nodesel, nodeselexitsol) - ccall( - (:SCIPsetNodeselExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), - scip, - nodesel, - nodeselexitsol, - ) + ccall((:SCIPsetNodeselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexitsol) end function SCIPfindNodesel(scip, name) - ccall( - (:SCIPfindNodesel, libscip), - Ptr{SCIP_NODESEL}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetNodesels(scip) - ccall( - (:SCIPgetNodesels, libscip), - Ptr{Ptr{SCIP_NODESEL}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNodesels, libscip), Ptr{Ptr{SCIP_NODESEL}}, (Ptr{SCIP},), scip) end function SCIPgetNNodesels(scip) @@ -13634,25 +6618,11 @@ function SCIPgetNNodesels(scip) end function SCIPsetNodeselStdPriority(scip, nodesel, priority) - ccall( - (:SCIPsetNodeselStdPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), - scip, - nodesel, - priority, - ) + ccall((:SCIPsetNodeselStdPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) end function SCIPsetNodeselMemsavePriority(scip, nodesel, priority) - ccall( - (:SCIPsetNodeselMemsavePriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), - scip, - nodesel, - priority, - ) + ccall((:SCIPsetNodeselMemsavePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) end function SCIPgetNodesel(scip) @@ -13667,10 +6637,6 @@ function SCIPsumepsilon(scip) ccall((:SCIPsumepsilon, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPlpfeastol(scip) - ccall((:SCIPlpfeastol, libscip), Cdouble, (Ptr{SCIP},), scip) -end - function SCIPbarrierconvtol(scip) ccall((:SCIPbarrierconvtol, libscip), Cdouble, (Ptr{SCIP},), scip) end @@ -13684,54 +6650,19 @@ function SCIPrelaxfeastol(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, Cuint), - scip, - lpfeastol, - printnewvalue, - ) + ccall((:SCIPchgFeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, feastol) end function SCIPchgDualfeastol(scip, dualfeastol) - ccall( - (:SCIPchgDualfeastol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - dualfeastol, - ) + ccall((:SCIPchgDualfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, dualfeastol) end function SCIPchgBarrierconvtol(scip, barrierconvtol) - ccall( - (:SCIPchgBarrierconvtol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - barrierconvtol, - ) + ccall((:SCIPchgBarrierconvtol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, barrierconvtol) end function SCIPchgRelaxfeastol(scip, relaxfeastol) - ccall( - (:SCIPchgRelaxfeastol, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - relaxfeastol, - ) + ccall((:SCIPchgRelaxfeastol, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, relaxfeastol) end function SCIPmarkLimitChanged(scip) @@ -13747,58 +6678,23 @@ function SCIPgetHugeValue(scip) end function SCIPisEQ(scip, val1, val2) - ccall( - (:SCIPisEQ, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisLT(scip, val1, val2) - ccall( - (:SCIPisLT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisLE(scip, val1, val2) - ccall( - (:SCIPisLE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisGT(scip, val1, val2) - ccall( - (:SCIPisGT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisGE(scip, val1, val2) - ccall( - (:SCIPisGE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisInfinity(scip, val) @@ -13826,24 +6722,11 @@ function SCIPisIntegral(scip, val) end function SCIPisScalingIntegral(scip, val, scalar) - ccall( - (:SCIPisScalingIntegral, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val, - scalar, - ) + ccall((:SCIPisScalingIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val, scalar) end function SCIPisFracIntegral(scip, val) - ccall( - (:SCIPisFracIntegral, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisFracIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPfloor(scip, val) @@ -13863,58 +6746,23 @@ function SCIPfrac(scip, val) end function SCIPisSumEQ(scip, val1, val2) - ccall( - (:SCIPisSumEQ, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumLT(scip, val1, val2) - ccall( - (:SCIPisSumLT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumLE(scip, val1, val2) - ccall( - (:SCIPisSumLE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumGT(scip, val1, val2) - ccall( - (:SCIPisSumGT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumGE(scip, val1, val2) - ccall( - (:SCIPisSumGE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumZero(scip, val) @@ -13930,58 +6778,23 @@ function SCIPisSumNegative(scip, val) end function SCIPisFeasEQ(scip, val1, val2) - ccall( - (:SCIPisFeasEQ, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisFeasEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasLT(scip, val1, val2) - ccall( - (:SCIPisFeasLT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisFeasLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasLE(scip, val1, val2) - ccall( - (:SCIPisFeasLE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisFeasLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasGT(scip, val1, val2) - ccall( - (:SCIPisFeasGT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisFeasGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasGE(scip, val1, val2) - ccall( - (:SCIPisFeasGE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisFeasGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisFeasZero(scip, val) @@ -13989,43 +6802,19 @@ function SCIPisFeasZero(scip, val) end function SCIPisFeasPositive(scip, val) - ccall( - (:SCIPisFeasPositive, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisFeasPositive, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPisFeasNegative(scip, val) - ccall( - (:SCIPisFeasNegative, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisFeasNegative, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPisFeasIntegral(scip, val) - ccall( - (:SCIPisFeasIntegral, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisFeasIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPisFeasFracIntegral(scip, val) - ccall( - (:SCIPisFeasFracIntegral, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisFeasFracIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPfeasFloor(scip, val) @@ -14045,912 +6834,287 @@ function SCIPfeasFrac(scip, val) end function SCIPisDualfeasEQ(scip, val1, val2) - ccall( - (:SCIPisDualfeasEQ, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisDualfeasEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasLT(scip, val1, val2) - ccall( - (:SCIPisDualfeasLT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisDualfeasLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasLE(scip, val1, val2) - ccall( - (:SCIPisDualfeasLE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisDualfeasLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasGT(scip, val1, val2) - ccall( - (:SCIPisDualfeasGT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisDualfeasGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasGE(scip, val1, val2) - ccall( - (:SCIPisDualfeasGE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisDualfeasGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisDualfeasZero(scip, val) - ccall( - (:SCIPisDualfeasZero, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisDualfeasZero, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPisDualfeasPositive(scip, val) - ccall( - (:SCIPisDualfeasPositive, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisDualfeasPositive, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPisDualfeasNegative(scip, val) - ccall( - (:SCIPisDualfeasNegative, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisDualfeasNegative, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPisDualfeasIntegral(scip, val) - ccall( - (:SCIPisDualfeasIntegral, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisDualfeasIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPisDualfeasFracIntegral(scip, val) - ccall( - (:SCIPisDualfeasFracIntegral, libscip), - Cuint, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPisDualfeasFracIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPdualfeasFloor(scip, val) - ccall( - (:SCIPdualfeasFloor, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPdualfeasFloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPdualfeasCeil(scip, val) - ccall( - (:SCIPdualfeasCeil, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPdualfeasCeil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPdualfeasRound(scip, val) - ccall( - (:SCIPdualfeasRound, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPdualfeasRound, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPdualfeasFrac(scip, val) - ccall( - (:SCIPdualfeasFrac, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - val, - ) + ccall((:SCIPdualfeasFrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) end function SCIPisLbBetter(scip, newlb, oldlb, oldub) - ccall( - (:SCIPisLbBetter, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), - scip, - newlb, - oldlb, - oldub, - ) + ccall((:SCIPisLbBetter, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newlb, oldlb, oldub) end function SCIPisUbBetter(scip, newub, oldlb, oldub) - ccall( - (:SCIPisUbBetter, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), - scip, - newub, - oldlb, - oldub, - ) + ccall((:SCIPisUbBetter, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newub, oldlb, oldub) end function SCIPisRelEQ(scip, val1, val2) - ccall( - (:SCIPisRelEQ, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisRelEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisRelLT(scip, val1, val2) - ccall( - (:SCIPisRelLT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisRelLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisRelLE(scip, val1, val2) - ccall( - (:SCIPisRelLE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisRelLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisRelGT(scip, val1, val2) - ccall( - (:SCIPisRelGT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisRelGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisRelGE(scip, val1, val2) - ccall( - (:SCIPisRelGE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisRelGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelEQ(scip, val1, val2) - ccall( - (:SCIPisSumRelEQ, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumRelEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelLT(scip, val1, val2) - ccall( - (:SCIPisSumRelLT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumRelLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelLE(scip, val1, val2) - ccall( - (:SCIPisSumRelLE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumRelLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelGT(scip, val1, val2) - ccall( - (:SCIPisSumRelGT, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumRelGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPisSumRelGE(scip, val1, val2) - ccall( - (:SCIPisSumRelGE, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - val1, - val2, - ) + ccall((:SCIPisSumRelGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) end function SCIPconvertRealToInt(scip, real) - ccall( - (:SCIPconvertRealToInt, libscip), - Cint, - (Ptr{SCIP}, Cdouble), - scip, - real, - ) + ccall((:SCIPconvertRealToInt, libscip), Cint, (Ptr{SCIP}, Cdouble), scip, real) end function SCIPconvertRealToLongint(scip, real) - ccall( - (:SCIPconvertRealToLongint, libscip), - Clonglong, - (Ptr{SCIP}, Cdouble), - scip, - real, - ) + ccall((:SCIPconvertRealToLongint, libscip), Clonglong, (Ptr{SCIP}, Cdouble), scip, real) end function SCIPisUpdateUnreliable(scip, newvalue, oldvalue) - ccall( - (:SCIPisUpdateUnreliable, libscip), - Cuint, - (Ptr{SCIP}, Cdouble, Cdouble), - scip, - newvalue, - oldvalue, - ) + ccall((:SCIPisUpdateUnreliable, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, newvalue, oldvalue) end function SCIPprintReal(scip, file, val, width, precision) - ccall( - (:SCIPprintReal, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}, Cdouble, Cint, Cint), - scip, - file, - val, - width, - precision, - ) + ccall((:SCIPprintReal, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}, Cdouble, Cint, Cint), scip, file, val, width, precision) end function SCIPparseReal(scip, str, value, endptr) - ccall( - (:SCIPparseReal, libscip), - Cuint, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), - scip, - str, - value, - endptr, - ) -end - -function SCIPaddBoolParam( - scip, - name, - desc, - valueptr, - isadvanced, - defaultvalue, - paramchgd, - paramdata, -) - ccall( - (:SCIPaddBoolParam, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cuint}, - Cuint, - Cuint, - 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}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cint}, - Cuint, - 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}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Clonglong}, - Cuint, - 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}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cdouble}, - Cuint, - 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}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cchar}, - Cuint, - Cchar, - Ptr{Cchar}, - 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}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Ptr{Cchar}}, - Cuint, - Ptr{Cchar}, - Ptr{Cvoid}, - Ptr{SCIP_PARAMDATA}, - ), - scip, - name, - desc, - valueptr, - isadvanced, - defaultvalue, - paramchgd, - paramdata, - ) + ccall((:SCIPparseReal, libscip), Cuint, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), scip, str, value, endptr) +end + +function SCIPparseRational(scip, str, value, endptr) + ccall((:SCIPparseRational, libscip), Cuint, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{Cchar}}), scip, str, value, endptr) +end + +function SCIPaddBoolParam(scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) + ccall((:SCIPaddBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cuint}, Cuint, Cuint, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cint}, Cuint, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Clonglong}, Cuint, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cdouble}, Cuint, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Cchar, Ptr{Cchar}, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Cuint, Ptr{Cchar}, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) end function SCIPisParamFixed(scip, name) - ccall( - (:SCIPisParamFixed, libscip), - Cuint, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPisParamFixed, libscip), Cuint, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetParam(scip, name) - ccall( - (:SCIPgetParam, libscip), - Ptr{SCIP_PARAM}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPgetParam, libscip), Ptr{SCIP_PARAM}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetBoolParam(scip, name, value) - ccall( - (:SCIPgetBoolParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cuint}), - scip, - name, - value, - ) + ccall((:SCIPgetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cuint}), scip, name, value) end function SCIPgetIntParam(scip, name, value) - ccall( - (:SCIPgetIntParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), - scip, - name, - value, - ) + ccall((:SCIPgetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), scip, name, value) end function SCIPgetLongintParam(scip, name, value) - ccall( - (:SCIPgetLongintParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Clonglong}), - scip, - name, - value, - ) + ccall((:SCIPgetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Clonglong}), scip, name, value) end function SCIPgetRealParam(scip, name, value) - ccall( - (:SCIPgetRealParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cdouble}), - scip, - name, - value, - ) + ccall((:SCIPgetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cdouble}), scip, name, value) end function SCIPgetCharParam(scip, name, value) - ccall( - (:SCIPgetCharParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), - scip, - name, - value, - ) + ccall((:SCIPgetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, name, value) end function SCIPgetStringParam(scip, name, value) - ccall( - (:SCIPgetStringParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), - scip, - name, - value, - ) + ccall((:SCIPgetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), scip, name, value) end function SCIPfixParam(scip, name) - ccall( - (:SCIPfixParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPunfixParam(scip, name) - ccall( - (:SCIPunfixParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPunfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPchgBoolParam(scip, param, value) - ccall( - (:SCIPchgBoolParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cuint), - scip, - param, - value, - ) + ccall((:SCIPchgBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cuint), scip, param, value) end function SCIPsetBoolParam(scip, name, value) - ccall( - (:SCIPsetBoolParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Cuint), - scip, - name, - value, - ) + ccall((:SCIPsetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cuint), scip, name, value) end function SCIPisBoolParamValid(scip, param, value) - ccall( - (:SCIPisBoolParamValid, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cuint), - scip, - param, - value, - ) + ccall((:SCIPisBoolParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cuint), scip, param, value) end function SCIPchgIntParam(scip, param, value) - ccall( - (:SCIPchgIntParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), - scip, - param, - value, - ) + ccall((:SCIPchgIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) end function SCIPsetIntParam(scip, name, value) - ccall( - (:SCIPsetIntParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Cint), - scip, - name, - value, - ) + ccall((:SCIPsetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cint), scip, name, value) end function SCIPisIntParamValid(scip, param, value) - ccall( - (:SCIPisIntParamValid, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), - scip, - param, - value, - ) + ccall((:SCIPisIntParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) end function SCIPchgLongintParam(scip, param, value) - ccall( - (:SCIPchgLongintParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), - scip, - param, - value, - ) + ccall((:SCIPchgLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) end function SCIPsetLongintParam(scip, name, value) - ccall( - (:SCIPsetLongintParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Clonglong), - scip, - name, - value, - ) + ccall((:SCIPsetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Clonglong), scip, name, value) end function SCIPisLongintParamValid(scip, param, value) - ccall( - (:SCIPisLongintParamValid, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), - scip, - param, - value, - ) + ccall((:SCIPisLongintParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) end function SCIPchgRealParam(scip, param, value) - ccall( - (:SCIPchgRealParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), - scip, - param, - value, - ) + ccall((:SCIPchgRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) end function SCIPsetRealParam(scip, name, value) - ccall( - (:SCIPsetRealParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Cdouble), - scip, - name, - value, - ) + ccall((:SCIPsetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cdouble), scip, name, value) end function SCIPisRealParamValid(scip, param, value) - ccall( - (:SCIPisRealParamValid, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), - scip, - param, - value, - ) + ccall((:SCIPisRealParamValid, libscip), Cuint, (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}, Cchar), - scip, - param, - value, - ) + ccall((:SCIPchgCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cchar), scip, param, value) end function SCIPsetCharParam(scip, name, value) - ccall( - (:SCIPsetCharParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Cchar), - scip, - name, - value, - ) + ccall((:SCIPsetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cchar), scip, name, value) end function SCIPisCharParamValid(scip, param, value) - ccall( - (:SCIPisCharParamValid, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cchar), - scip, - param, - value, - ) + ccall((:SCIPisCharParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cchar), scip, param, value) end function SCIPchgStringParam(scip, param, value) - ccall( - (:SCIPchgStringParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}), - scip, - param, - value, - ) + ccall((:SCIPchgStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}), scip, param, value) end function SCIPsetStringParam(scip, name, value) - ccall( - (:SCIPsetStringParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), - scip, - name, - value, - ) + ccall((:SCIPsetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, name, value) end function SCIPisStringParamValid(scip, param, value) - ccall( - (:SCIPisStringParamValid, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}), - scip, - param, - value, - ) + ccall((:SCIPisStringParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}), scip, param, value) +end + +function SCIPsetParam(scip, name, value) + ccall((:SCIPsetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, name, value) end function SCIPreadParams(scip, filename) - ccall( - (:SCIPreadParams, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - filename, - ) + ccall((:SCIPreadParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) end function SCIPwriteParam(scip, param, filename, comments, onlychanged) - ccall( - (:SCIPwriteParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}, Cuint, Cuint), - scip, - param, - filename, - comments, - onlychanged, - ) + ccall((:SCIPwriteParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}, Cuint, Cuint), scip, param, filename, comments, onlychanged) end function SCIPwriteParams(scip, filename, comments, onlychanged) - ccall( - (:SCIPwriteParams, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Cuint, Cuint), - scip, - filename, - comments, - onlychanged, - ) + ccall((:SCIPwriteParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cuint, Cuint), scip, filename, comments, onlychanged) end function SCIPresetParam(scip, name) - ccall( - (:SCIPresetParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPresetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPresetParams(scip) @@ -14958,57 +7122,23 @@ function SCIPresetParams(scip) end function SCIPsetEmphasis(scip, paramemphasis, quiet) - ccall( - (:SCIPsetEmphasis, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, SCIP_PARAMEMPHASIS, Cuint), - scip, - paramemphasis, - quiet, - ) + ccall((:SCIPsetEmphasis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMEMPHASIS, Cuint), scip, paramemphasis, quiet) end function SCIPsetSubscipsOff(scip, quiet) - ccall( - (:SCIPsetSubscipsOff, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint), - scip, - quiet, - ) + ccall((:SCIPsetSubscipsOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, quiet) end function SCIPsetHeuristics(scip, paramsetting, quiet) - ccall( - (:SCIPsetHeuristics, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), - scip, - paramsetting, - quiet, - ) + ccall((:SCIPsetHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), scip, paramsetting, quiet) end function SCIPsetPresolving(scip, paramsetting, quiet) - ccall( - (:SCIPsetPresolving, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), - scip, - paramsetting, - quiet, - ) + ccall((:SCIPsetPresolving, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), scip, paramsetting, quiet) end function SCIPsetSeparating(scip, paramsetting, quiet) - ccall( - (:SCIPsetSeparating, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), - scip, - paramsetting, - quiet, - ) + ccall((:SCIPsetSeparating, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), scip, paramsetting, quiet) end function SCIPgetParams(scip) @@ -15023,169 +7153,40 @@ function SCIPgetSubscipsOff(scip) ccall((:SCIPgetSubscipsOff, libscip), Cuint, (Ptr{SCIP},), scip) end -function SCIPincludePresol( - scip, - name, - desc, - priority, - maxrounds, - timing, - presolcopy, - presolfree, - presolinit, - presolexit, - presolinitpre, - presolexitpre, - presolexec, - presoldata, -) - ccall( - (:SCIPincludePresol, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - SCIP_PRESOLTIMING, - Ptr{Cvoid}, - Ptr{SCIP_PRESOLDATA}, - ), - scip, - presolptr, - name, - desc, - priority, - maxrounds, - timing, - presolexec, - presoldata, - ) +function SCIPincludePresol(scip, name, desc, priority, maxrounds, timing, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) + ccall((:SCIPincludePresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, presolptr, name, desc, priority, maxrounds, timing, presolexec, presoldata) end function SCIPsetPresolCopy(scip, presol, presolcopy) - ccall( - (:SCIPsetPresolCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), - scip, - presol, - presolcopy, - ) + ccall((:SCIPsetPresolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolcopy) end function SCIPsetPresolFree(scip, presol, presolfree) - ccall( - (:SCIPsetPresolFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), - scip, - presol, - presolfree, - ) + ccall((:SCIPsetPresolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolfree) end function SCIPsetPresolInit(scip, presol, presolinit) - ccall( - (:SCIPsetPresolInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), - scip, - presol, - presolinit, - ) + ccall((:SCIPsetPresolInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinit) end function SCIPsetPresolExit(scip, presol, presolexit) - ccall( - (:SCIPsetPresolExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), - scip, - presol, - presolexit, - ) + ccall((:SCIPsetPresolExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexit) end function SCIPsetPresolInitpre(scip, presol, presolinitpre) - ccall( - (:SCIPsetPresolInitpre, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), - scip, - presol, - presolinitpre, - ) + ccall((:SCIPsetPresolInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinitpre) end function SCIPsetPresolExitpre(scip, presol, presolexitpre) - ccall( - (:SCIPsetPresolExitpre, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), - scip, - presol, - presolexitpre, - ) + ccall((:SCIPsetPresolExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexitpre) end function SCIPfindPresol(scip, name) - ccall( - (:SCIPfindPresol, libscip), - Ptr{SCIP_PRESOL}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindPresol, libscip), Ptr{SCIP_PRESOL}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetPresols(scip) @@ -15197,183 +7198,47 @@ function SCIPgetNPresols(scip) end function SCIPsetPresolPriority(scip, presol, priority) - ccall( - (:SCIPsetPresolPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Cint), - scip, - presol, - priority, - ) + ccall((:SCIPsetPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Cint), scip, presol, priority) end function SCIPgetNPresolRounds(scip) ccall((:SCIPgetNPresolRounds, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPincludePricer( - scip, - name, - desc, - priority, - delay, - pricercopy, - pricerfree, - pricerinit, - pricerexit, - pricerinitsol, - pricerexitsol, - pricerredcost, - pricerfarkas, - pricerdata, -) - ccall( - (:SCIPincludePricer, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cuint, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cuint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_PRICERDATA}, - ), - scip, - pricerptr, - name, - desc, - priority, - delay, - pricerredcost, - pricerfarkas, - pricerdata, - ) +function SCIPincludePricer(scip, name, desc, priority, delay, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) + ccall((:SCIPincludePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, pricerptr, name, desc, priority, delay, pricerredcost, pricerfarkas, pricerdata) end function SCIPsetPricerCopy(scip, pricer, pricercopy) - ccall( - (:SCIPsetPricerCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), - scip, - pricer, - pricercopy, - ) + ccall((:SCIPsetPricerCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricercopy) end function SCIPsetPricerFree(scip, pricer, pricerfree) - ccall( - (:SCIPsetPricerFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), - scip, - pricer, - pricerfree, - ) + ccall((:SCIPsetPricerFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerfree) end function SCIPsetPricerInit(scip, pricer, pricerinit) - ccall( - (:SCIPsetPricerInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), - scip, - pricer, - pricerinit, - ) + ccall((:SCIPsetPricerInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinit) end function SCIPsetPricerExit(scip, pricer, pricerexit) - ccall( - (:SCIPsetPricerExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), - scip, - pricer, - pricerexit, - ) + ccall((:SCIPsetPricerExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexit) end function SCIPsetPricerInitsol(scip, pricer, pricerinitsol) - ccall( - (:SCIPsetPricerInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), - scip, - pricer, - pricerinitsol, - ) + ccall((:SCIPsetPricerInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinitsol) end function SCIPsetPricerExitsol(scip, pricer, pricerexitsol) - ccall( - (:SCIPsetPricerExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), - scip, - pricer, - pricerexitsol, - ) + ccall((:SCIPsetPricerExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexitsol) end function SCIPfindPricer(scip, name) - ccall( - (:SCIPfindPricer, libscip), - Ptr{SCIP_PRICER}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindPricer, libscip), Ptr{SCIP_PRICER}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetPricers(scip) @@ -15389,203 +7254,75 @@ function SCIPgetNActivePricers(scip) end function SCIPsetPricerPriority(scip, pricer, priority) - ccall( - (:SCIPsetPricerPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}, Cint), - scip, - pricer, - priority, - ) + ccall((:SCIPsetPricerPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Cint), scip, pricer, priority) end function SCIPactivatePricer(scip, pricer) - ccall( - (:SCIPactivatePricer, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}), - scip, - pricer, - ) + ccall((:SCIPactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}), scip, pricer) end function SCIPdeactivatePricer(scip, pricer) - ccall( - (:SCIPdeactivatePricer, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PRICER}), - scip, - pricer, - ) -end - -function SCIPcreateProb( - scip, - name, - probdelorig, - probtrans, - probdeltrans, - probinitsol, - probexitsol, - probcopy, - probdata, -) - ccall( - (:SCIPcreateProb, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_PROBDATA}, - ), - scip, - name, - probdelorig, - probtrans, - probdeltrans, - probinitsol, - probexitsol, - probcopy, - probdata, - ) + ccall((:SCIPdeactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}), scip, pricer) +end + +function SCIPcreateProb(scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) + ccall((:SCIPcreateProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, 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}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPcreateProbBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPsetProbDelorig(scip, probdelorig) - ccall( - (:SCIPsetProbDelorig, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cvoid}), - scip, - probdelorig, - ) + ccall((:SCIPsetProbDelorig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probdelorig) end function SCIPsetProbTrans(scip, probtrans) - ccall( - (:SCIPsetProbTrans, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cvoid}), - scip, - probtrans, - ) + ccall((:SCIPsetProbTrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probtrans) end function SCIPsetProbDeltrans(scip, probdeltrans) - ccall( - (:SCIPsetProbDeltrans, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cvoid}), - scip, - probdeltrans, - ) + ccall((:SCIPsetProbDeltrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probdeltrans) end function SCIPsetProbInitsol(scip, probinitsol) - ccall( - (:SCIPsetProbInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cvoid}), - scip, - probinitsol, - ) + ccall((:SCIPsetProbInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probinitsol) end function SCIPsetProbExitsol(scip, probexitsol) - ccall( - (:SCIPsetProbExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cvoid}), - scip, - probexitsol, - ) + ccall((:SCIPsetProbExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probexitsol) end function SCIPsetProbCopy(scip, probcopy) - ccall( - (:SCIPsetProbCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cvoid}), - scip, - probcopy, - ) + ccall((:SCIPsetProbCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probcopy) end function SCIPreadProb(scip, filename, extension) - ccall( - (:SCIPreadProb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), - scip, - filename, - extension, - ) + ccall((:SCIPreadProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, filename, extension) +end + +function SCIPprintOrigProblem(scip, file, extension, genericnames) + ccall((:SCIPprintOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint), scip, file, extension, genericnames) +end + +function SCIPprintTransProblem(scip, file, extension, genericnames) + ccall((:SCIPprintTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint), scip, file, extension, genericnames) end function SCIPwriteOrigProblem(scip, filename, extension, genericnames) - ccall( - (:SCIPwriteOrigProblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint), - scip, - filename, - extension, - genericnames, - ) + ccall((:SCIPwriteOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint), scip, filename, extension, genericnames) end function SCIPwriteTransProblem(scip, filename, extension, genericnames) - ccall( - (:SCIPwriteTransProblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint), - scip, - filename, - extension, - genericnames, - ) + ccall((:SCIPwriteTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint), 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}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), - scip, - randseed, - permuteconss, - permutebinvars, - permuteintvars, - permuteimplvars, - permutecontvars, - ) +function SCIPpermuteProb(scip, randseed, permuteconss, permutebinvars, permuteintvars, permutebinimplvars, permuteintimplvars, permutecontimplvars, permutecontvars) + ccall((:SCIPpermuteProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, randseed, permuteconss, permutebinvars, permuteintvars, permutebinimplvars, permuteintimplvars, permutecontimplvars, permutecontvars) end function SCIPgetProbData(scip) @@ -15593,13 +7330,7 @@ function SCIPgetProbData(scip) end function SCIPsetProbData(scip, probdata) - ccall( - (:SCIPsetProbData, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROBDATA}), - scip, - probdata, - ) + ccall((:SCIPsetProbData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROBDATA}), scip, probdata) end function SCIPgetProbName(scip) @@ -15607,26 +7338,11 @@ function SCIPgetProbName(scip) end function SCIPsetProbName(scip, name) - ccall( - (:SCIPsetProbName, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPsetProbName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPchgReoptObjective(scip, objsense, vars, coefs, nvars) - ccall( - (:SCIPchgReoptObjective, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, SCIP_OBJSENSE, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), - scip, - objsense, - vars, - coefs, - nvars, - ) + ccall((:SCIPchgReoptObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), scip, objsense, vars, coefs, nvars) end function SCIPgetObjsense(scip) @@ -15634,39 +7350,29 @@ function SCIPgetObjsense(scip) end function SCIPsetObjsense(scip, objsense) - ccall( - (:SCIPsetObjsense, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, SCIP_OBJSENSE), - scip, - objsense, - ) + ccall((:SCIPsetObjsense, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE), scip, objsense) end function SCIPaddObjoffset(scip, addval) - ccall( - (:SCIPaddObjoffset, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - addval, - ) + ccall((:SCIPaddObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) +end + +function SCIPaddOrigObjoffsetExact(scip, addval) + ccall((:SCIPaddOrigObjoffsetExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, addval) end function SCIPaddOrigObjoffset(scip, addval) - ccall( - (:SCIPaddOrigObjoffset, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - addval, - ) + ccall((:SCIPaddOrigObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) end function SCIPgetOrigObjoffset(scip) ccall((:SCIPgetOrigObjoffset, libscip), Cdouble, (Ptr{SCIP},), scip) end +function SCIPgetOrigObjoffsetExact(scip) + ccall((:SCIPgetOrigObjoffsetExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP},), scip) +end + function SCIPgetOrigObjscale(scip) ccall((:SCIPgetOrigObjscale, libscip), Cdouble, (Ptr{SCIP},), scip) end @@ -15680,13 +7386,7 @@ function SCIPgetTransObjscale(scip) end function SCIPsetObjlimit(scip, objlimit) - ccall( - (:SCIPsetObjlimit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - objlimit, - ) + ccall((:SCIPsetObjlimit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, objlimit) end function SCIPgetObjlimit(scip) @@ -15706,66 +7406,19 @@ function SCIPgetObjNorm(scip) end function SCIPaddVar(scip, var) - ccall( - (:SCIPaddVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPaddVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPaddPricedVar(scip, var, score) - ccall( - (:SCIPaddPricedVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - score, - ) + ccall((:SCIPaddPricedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, score) end function SCIPdelVar(scip, var, deleted) - ccall( - (:SCIPdelVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cuint}), - scip, - var, - deleted, - ) -end - -function SCIPgetVarsData( - scip, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, -) - ccall( - (:SCIPgetVarsData, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - ) + ccall((:SCIPdelVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cuint}), 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) @@ -15788,6 +7441,18 @@ function SCIPgetNImplVars(scip) ccall((:SCIPgetNImplVars, libscip), Cint, (Ptr{SCIP},), scip) end +function SCIPgetNBinImplVars(scip) + ccall((:SCIPgetNBinImplVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNIntImplVars(scip) + ccall((:SCIPgetNIntImplVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNContImplVars(scip) + ccall((:SCIPgetNContImplVars, libscip), Cint, (Ptr{SCIP},), scip) +end + function SCIPgetNContVars(scip) ccall((:SCIPgetNContVars, libscip), Cint, (Ptr{SCIP},), scip) end @@ -15804,35 +7469,8 @@ 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, - ) +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) @@ -15855,6 +7493,18 @@ function SCIPgetNOrigImplVars(scip) ccall((:SCIPgetNOrigImplVars, libscip), Cint, (Ptr{SCIP},), scip) end +function SCIPgetNOrigBinImplVars(scip) + ccall((:SCIPgetNOrigBinImplVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNOrigIntImplVars(scip) + ccall((:SCIPgetNOrigIntImplVars, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPgetNOrigContImplVars(scip) + ccall((:SCIPgetNOrigContImplVars, libscip), Cint, (Ptr{SCIP},), scip) +end + function SCIPgetNOrigContVars(scip) ccall((:SCIPgetNOrigContVars, libscip), Cint, (Ptr{SCIP},), scip) end @@ -15863,48 +7513,12 @@ 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, - ) +function SCIPgetSolVarsData(scip, sol, vars, nvars, nbinvars, nintvars, nbinimplvars, nintimplvars, ncontimplvars, 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}, Ptr{Cint}, Ptr{Cint}), scip, sol, vars, nvars, nbinvars, nintvars, nbinimplvars, nintimplvars, ncontimplvars, ncontvars) end function SCIPfindVar(scip, name) - ccall( - (:SCIPfindVar, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPallVarsInProb(scip) @@ -15912,43 +7526,23 @@ function SCIPallVarsInProb(scip) end function SCIPaddCons(scip, cons) - ccall( - (:SCIPaddCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPaddCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPaddConsUpgrade(scip, oldcons, newcons) + ccall((:SCIPaddConsUpgrade, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, oldcons, newcons) end function SCIPdelCons(scip, cons) - ccall( - (:SCIPdelCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPdelCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPfindOrigCons(scip, name) - ccall( - (:SCIPfindOrigCons, libscip), - Ptr{SCIP_CONS}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindOrigCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPfindCons(scip, name) - ccall( - (:SCIPfindCons, libscip), - Ptr{SCIP_CONS}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetNUpgrConss(scip) @@ -15975,86 +7569,28 @@ 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, - Cuint, - ), - scip, - node, - cons, - validnode, - conftype, - iscutoffinvolved, - ) +function SCIPaddConflict(scip, node, cons, validnode, conftype, iscutoffinvolved) + ccall((:SCIPaddConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_NODE}, SCIP_CONFTYPE, Cuint), scip, node, cons, validnode, conftype, iscutoffinvolved) end function SCIPclearConflictStore(scip, event) - ccall( - (:SCIPclearConflictStore, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EVENT}), - scip, - event, - ) + ccall((:SCIPclearConflictStore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENT}), scip, event) end function SCIPaddConsNode(scip, node, cons, validnode) - ccall( - (:SCIPaddConsNode, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), - scip, - node, - cons, - validnode, - ) + ccall((:SCIPaddConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, node, cons, validnode) end function SCIPaddConsLocal(scip, cons, validnode) - ccall( - (:SCIPaddConsLocal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), - scip, - cons, - validnode, - ) + ccall((:SCIPaddConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, cons, validnode) end function SCIPdelConsNode(scip, node, cons) - ccall( - (:SCIPdelConsNode, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}), - scip, - node, - cons, - ) + ccall((:SCIPdelConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}), scip, node, cons) end function SCIPdelConsLocal(scip, cons) - ccall( - (:SCIPdelConsLocal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPdelConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPgetLocalOrigEstimate(scip) @@ -16074,76 +7610,31 @@ function SCIPgetLocalLowerbound(scip) end function SCIPgetNodeDualbound(scip, node) - ccall( - (:SCIPgetNodeDualbound, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_NODE}), - scip, - node, - ) + ccall((:SCIPgetNodeDualbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) end function SCIPgetNodeLowerbound(scip, node) - ccall( - (:SCIPgetNodeLowerbound, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_NODE}), - scip, - node, - ) + ccall((:SCIPgetNodeLowerbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) end function SCIPupdateLocalDualbound(scip, newbound) - ccall( - (:SCIPupdateLocalDualbound, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - newbound, - ) + ccall((:SCIPupdateLocalDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) end function SCIPupdateLocalLowerbound(scip, newbound) - ccall( - (:SCIPupdateLocalLowerbound, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - newbound, - ) + ccall((:SCIPupdateLocalLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) end function SCIPupdateNodeDualbound(scip, node, newbound) - ccall( - (:SCIPupdateNodeDualbound, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), - scip, - node, - newbound, - ) + ccall((:SCIPupdateNodeDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) end function SCIPupdateNodeLowerbound(scip, node, newbound) - ccall( - (:SCIPupdateNodeLowerbound, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), - scip, - node, - newbound, - ) + ccall((:SCIPupdateNodeLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) end function SCIPchgChildPrio(scip, child, priority) - ccall( - (:SCIPchgChildPrio, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), - scip, - child, - priority, - ) + ccall((:SCIPchgChildPrio, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, child, priority) end function SCIPinProbing(scip) @@ -16163,13 +7654,7 @@ function SCIPgetProbingDepth(scip) end function SCIPbacktrackProbing(scip, probingdepth) - ccall( - (:SCIPbacktrackProbing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint), - scip, - probingdepth, - ) + ccall((:SCIPbacktrackProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint), scip, probingdepth) end function SCIPendProbing(scip) @@ -16177,57 +7662,23 @@ function SCIPendProbing(scip) end function SCIPchgVarLbProbing(scip, var, newbound) - ccall( - (:SCIPchgVarLbProbing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newbound, - ) + ccall((:SCIPchgVarLbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarUbProbing(scip, var, newbound) - ccall( - (:SCIPchgVarUbProbing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newbound, - ) + ccall((:SCIPchgVarUbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPgetVarObjProbing(scip, var) - ccall( - (:SCIPgetVarObjProbing, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarObjProbing, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPfixVarProbing(scip, var, fixedval) - ccall( - (:SCIPfixVarProbing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - fixedval, - ) + ccall((:SCIPfixVarProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, fixedval) end function SCIPchgVarObjProbing(scip, var, newobj) - ccall( - (:SCIPchgVarObjProbing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newobj, - ) + ccall((:SCIPchgVarObjProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end function SCIPisObjChangedProbing(scip) @@ -16235,513 +7686,119 @@ function SCIPisObjChangedProbing(scip) end function SCIPpropagateProbing(scip, maxproprounds, cutoff, ndomredsfound) - ccall( - (:SCIPpropagateProbing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Clonglong}), - scip, - maxproprounds, - cutoff, - ndomredsfound, - ) + ccall((:SCIPpropagateProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Clonglong}), scip, maxproprounds, cutoff, ndomredsfound) end function SCIPpropagateProbingImplications(scip, cutoff) - ccall( - (:SCIPpropagateProbingImplications, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cuint}), - scip, - cutoff, - ) + ccall((:SCIPpropagateProbingImplications, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, cutoff) end function SCIPsolveProbingLP(scip, itlim, lperror, cutoff) - ccall( - (:SCIPsolveProbingLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), - scip, - itlim, - lperror, - cutoff, - ) -end - -function SCIPsolveProbingLPWithPricing( - scip, - pretendroot, - displayinfo, - maxpricerounds, - lperror, - cutoff, -) - ccall( - (:SCIPsolveProbingLPWithPricing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint, Cuint, Cint, Ptr{Cuint}, Ptr{Cuint}), - scip, - pretendroot, - displayinfo, - maxpricerounds, - lperror, - cutoff, - ) + ccall((:SCIPsolveProbingLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, itlim, lperror, cutoff) end -const SCIP_LPiState = Cvoid - -const SCIP_LPISTATE = SCIP_LPiState - -const SCIP_LPiNorms = Cvoid - -const SCIP_LPINORMS = SCIP_LPiNorms +function SCIPsolveProbingLPWithPricing(scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) + ccall((:SCIPsolveProbingLPWithPricing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Cuint, Cint, Ptr{Cuint}, Ptr{Cuint}), 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}}, - Cuint, - Cuint, - ), - scip, - lpistate, - lpinorms, - primalfeas, - dualfeas, - ) + ccall((:SCIPsetProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LPISTATE}}, Ptr{Ptr{SCIP_LPINORMS}}, Cuint, Cuint), scip, lpistate, lpinorms, primalfeas, dualfeas) end function SCIPaddRowProbing(scip, row) - ccall( - (:SCIPaddRowProbing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROW}), - scip, - row, - ) + ccall((:SCIPaddRowProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) end function SCIPapplyCutsProbing(scip, cutoff) - ccall( - (:SCIPapplyCutsProbing, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cuint}), - scip, - cutoff, - ) + ccall((:SCIPapplyCutsProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, cutoff) end function SCIPsolveProbingRelax(scip, cutoff) - ccall( - (:SCIPsolveProbingRelax, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cuint}), - scip, - cutoff, - ) + ccall((:SCIPsolveProbingRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, cutoff) end function SCIPsnprintfProbingStats(scip, strbuf, len) - ccall( - (:SCIPsnprintfProbingStats, libscip), - Ptr{Cchar}, - (Ptr{SCIP}, Ptr{Cchar}, Cint), - scip, - strbuf, - len, - ) -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{Cuint}, - ), - scip, - diveset, - divetype, - divecand, - divecandsol, - divecandfrac, - candscore, - roundup, - ) + ccall((:SCIPsnprintfProbingStats, libscip), Ptr{Cchar}, (Ptr{SCIP}, Ptr{Cchar}, Cint), scip, strbuf, len) +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{Cuint}), scip, diveset, divetype, divecand, divecandsol, divecandfrac, candscore, roundup) end function SCIPupdateDivesetLPStats(scip, diveset, niterstoadd, divecontext) - ccall( - (:SCIPupdateDivesetLPStats, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Clonglong, SCIP_DIVECONTEXT), - scip, - diveset, - niterstoadd, - divecontext, - ) -end - -function SCIPupdateDivesetStats( - scip, - diveset, - nprobingnodes, - nbacktracks, - nsolsfound, - nbestsolsfound, - nconflictsfound, - leavewassol, - divecontext, -) - ccall( - (:SCIPupdateDivesetStats, libscip), - Cvoid, - ( - Ptr{SCIP}, - Ptr{SCIP_DIVESET}, - Cint, - Cint, - Clonglong, - Clonglong, - Clonglong, - Cuint, - SCIP_DIVECONTEXT, - ), - scip, - diveset, - nprobingnodes, - nbacktracks, - nsolsfound, - nbestsolsfound, - nconflictsfound, - leavewassol, - divecontext, - ) + ccall((:SCIPupdateDivesetLPStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Clonglong, SCIP_DIVECONTEXT), scip, diveset, niterstoadd, divecontext) +end + +function SCIPupdateDivesetStats(scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol, divecontext) + ccall((:SCIPupdateDivesetStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Cint, Cint, Clonglong, Clonglong, Clonglong, Cuint, SCIP_DIVECONTEXT), scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol, divecontext) end function SCIPgetDiveBoundChanges(scip, diveset, sol, success, infeasible) - ccall( - (:SCIPgetDiveBoundChanges, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{Cuint}, Ptr{Cuint}), - scip, - diveset, - sol, - success, - infeasible, - ) + ccall((:SCIPgetDiveBoundChanges, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint), - 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}, - Cuint, - ), - scip, - variables, - directions, - values, - ndivebdchgs, - preferred, - ) + ccall((:SCIPaddDiveBoundChange, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble, Cuint), 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}, Cuint), scip, variables, directions, values, ndivebdchgs, preferred) end function SCIPclearDiveBoundChanges(scip) ccall((:SCIPclearDiveBoundChanges, libscip), Cvoid, (Ptr{SCIP},), scip) end -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}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Cuint, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Cuint, - SCIP_PROPTIMING, - Ptr{Cvoid}, - Ptr{SCIP_PROPDATA}, - ), - scip, - propptr, - name, - desc, - priority, - freq, - delay, - timingmask, - propexec, - propdata, - ) +function SCIPincludeProp(scip, name, desc, priority, freq, delay, timingmask, presolpriority, presolmaxrounds, presoltiming, propcopy, propfree, propinit, propexit, propinitpre, propexitpre, propinitsol, propexitsol, proppresol, propexec, propresprop, propdata) + ccall((:SCIPincludeProp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cuint, SCIP_PROPTIMING, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, propptr, name, desc, priority, freq, delay, timingmask, propexec, propdata) end function SCIPsetPropCopy(scip, prop, propcopy) - ccall( - (:SCIPsetPropCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), - scip, - prop, - propcopy, - ) + ccall((:SCIPsetPropCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propcopy) end function SCIPsetPropFree(scip, prop, propfree) - ccall( - (:SCIPsetPropFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), - scip, - prop, - propfree, - ) + ccall((:SCIPsetPropFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propfree) end function SCIPsetPropInit(scip, prop, propinit) - ccall( - (:SCIPsetPropInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), - scip, - prop, - propinit, - ) + ccall((:SCIPsetPropInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinit) end function SCIPsetPropExit(scip, prop, propexit) - ccall( - (:SCIPsetPropExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), - scip, - prop, - propexit, - ) + ccall((:SCIPsetPropExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexit) end function SCIPsetPropInitsol(scip, prop, propinitsol) - ccall( - (:SCIPsetPropInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), - scip, - prop, - propinitsol, - ) + ccall((:SCIPsetPropInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitsol) end function SCIPsetPropExitsol(scip, prop, propexitsol) - ccall( - (:SCIPsetPropExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), - scip, - prop, - propexitsol, - ) + ccall((:SCIPsetPropExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitsol) end function SCIPsetPropInitpre(scip, prop, propinitpre) - ccall( - (:SCIPsetPropInitpre, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), - scip, - prop, - propinitpre, - ) + ccall((:SCIPsetPropInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitpre) end function SCIPsetPropExitpre(scip, prop, propexitpre) - ccall( - (:SCIPsetPropExitpre, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), - scip, - prop, - propexitpre, - ) -end - -function SCIPsetPropPresol( - scip, - prop, - proppresol, - presolpriority, - presolmaxrounds, - presoltiming, -) - ccall( - (:SCIPsetPropPresol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}, Cint, Cint, SCIP_PRESOLTIMING), - scip, - prop, - proppresol, - presolpriority, - presolmaxrounds, - presoltiming, - ) + ccall((: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, - ) + 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}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindProp, libscip), Ptr{SCIP_PROP}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetProps(scip) @@ -16753,187 +7810,55 @@ function SCIPgetNProps(scip) end function SCIPsetPropPriority(scip, prop, priority) - ccall( - (:SCIPsetPropPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), - scip, - prop, - priority, - ) + ccall((:SCIPsetPropPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, priority) end function SCIPsetPropPresolPriority(scip, prop, presolpriority) - ccall( - (:SCIPsetPropPresolPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), - scip, - prop, - presolpriority, - ) + ccall((:SCIPsetPropPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, presolpriority) end function SCIPcreateRandom(scip, randnumgen, initialseed, useglobalseed) - ccall( - (:SCIPcreateRandom, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}, Cuint, Cuint), - scip, - randnumgen, - initialseed, - useglobalseed, - ) + ccall((:SCIPcreateRandom, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}, Cuint, Cuint), scip, randnumgen, initialseed, useglobalseed) end function SCIPfreeRandom(scip, randnumgen) - ccall( - (:SCIPfreeRandom, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}), - scip, - randnumgen, - ) + ccall((:SCIPfreeRandom, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}), scip, randnumgen) end function SCIPsetRandomSeed(scip, randnumgen, seed) - ccall( - (:SCIPsetRandomSeed, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_RANDNUMGEN}, Cuint), - scip, - randnumgen, - seed, - ) + ccall((:SCIPsetRandomSeed, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RANDNUMGEN}, Cuint), scip, randnumgen, seed) end function SCIPinitializeRandomSeed(scip, initialseedvalue) - ccall( - (:SCIPinitializeRandomSeed, libscip), - Cuint, - (Ptr{SCIP}, Cuint), - scip, - initialseedvalue, - ) -end - -function SCIPincludeReader( - scip, - name, - desc, - extension, - readercopy, - readerfree, - readerread, - readerwrite, - readerdata, -) - ccall( - (:SCIPincludeReader, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cchar}, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{SCIP_READERDATA}, - ), - scip, - readerptr, - name, - desc, - extension, - readerdata, - ) + ccall((:SCIPinitializeRandomSeed, libscip), Cuint, (Ptr{SCIP}, Cuint), scip, initialseedvalue) +end + +function SCIPincludeReader(scip, name, desc, extension, readercopy, readerfree, readerread, readerwrite, readerdata) + ccall((:SCIPincludeReader, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{SCIP_READERDATA}), scip, readerptr, name, desc, extension, readerdata) end function SCIPsetReaderCopy(scip, reader, readercopy) - ccall( - (:SCIPsetReaderCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), - scip, - reader, - readercopy, - ) + ccall((:SCIPsetReaderCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readercopy) end function SCIPsetReaderFree(scip, reader, readerfree) - ccall( - (:SCIPsetReaderFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), - scip, - reader, - readerfree, - ) + ccall((:SCIPsetReaderFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerfree) end function SCIPsetReaderRead(scip, reader, readerread) - ccall( - (:SCIPsetReaderRead, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), - scip, - reader, - readerread, - ) + ccall((:SCIPsetReaderRead, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerread) end function SCIPsetReaderWrite(scip, reader, readerwrite) - ccall( - (:SCIPsetReaderWrite, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), - scip, - reader, - readerwrite, - ) + ccall((:SCIPsetReaderWrite, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerwrite) end function SCIPfindReader(scip, name) - ccall( - (:SCIPfindReader, libscip), - Ptr{SCIP_READER}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindReader, libscip), Ptr{SCIP_READER}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetReaders(scip) @@ -16944,163 +7869,40 @@ function SCIPgetNReaders(scip) ccall((:SCIPgetNReaders, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPincludeRelax( - scip, - name, - desc, - priority, - freq, - relaxcopy, - relaxfree, - relaxinit, - relaxexit, - relaxinitsol, - relaxexitsol, - relaxexec, - relaxdata, -) - ccall( - (:SCIPincludeRelax, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Ptr{Cvoid}, - Ptr{SCIP_RELAXDATA}, - ), - scip, - relaxptr, - name, - desc, - priority, - freq, - relaxexec, - relaxdata, - ) +function SCIPincludeRelax(scip, name, desc, priority, freq, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) + ccall((:SCIPincludeRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, relaxptr, name, desc, priority, freq, relaxexec, relaxdata) end function SCIPsetRelaxCopy(scip, relax, relaxcopy) - ccall( - (:SCIPsetRelaxCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), - scip, - relax, - relaxcopy, - ) + ccall((:SCIPsetRelaxCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxcopy) end function SCIPsetRelaxFree(scip, relax, relaxfree) - ccall( - (:SCIPsetRelaxFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), - scip, - relax, - relaxfree, - ) + ccall((:SCIPsetRelaxFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxfree) end function SCIPsetRelaxInit(scip, relax, relaxinit) - ccall( - (:SCIPsetRelaxInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), - scip, - relax, - relaxinit, - ) + ccall((:SCIPsetRelaxInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinit) end function SCIPsetRelaxExit(scip, relax, relaxexit) - ccall( - (:SCIPsetRelaxExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), - scip, - relax, - relaxexit, - ) + ccall((:SCIPsetRelaxExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexit) end function SCIPsetRelaxInitsol(scip, relax, relaxinitsol) - ccall( - (:SCIPsetRelaxInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), - scip, - relax, - relaxinitsol, - ) + ccall((:SCIPsetRelaxInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinitsol) end function SCIPsetRelaxExitsol(scip, relax, relaxexitsol) - ccall( - (:SCIPsetRelaxExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), - scip, - relax, - relaxexitsol, - ) + ccall((:SCIPsetRelaxExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexitsol) end function SCIPfindRelax(scip, name) - ccall( - (:SCIPfindRelax, libscip), - Ptr{SCIP_RELAX}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindRelax, libscip), Ptr{SCIP_RELAX}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetRelaxs(scip) @@ -17112,498 +7914,115 @@ function SCIPgetNRelaxs(scip) end function SCIPsetRelaxPriority(scip, relax, priority) - ccall( - (:SCIPsetRelaxPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint), - scip, - relax, - priority, - ) -end - -function SCIPgetReoptChildIDs(scip, node, ids, mem, nids) - ccall( - (:SCIPgetReoptChildIDs, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}, 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{Cuint}, Cint, Ptr{Cint}), - scip, - node, - ids, - mem, - nids, - ) + ccall((:SCIPsetRelaxPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint), scip, relax, priority) end -function SCIPgetNReoptnodes(scip, node) - ccall( - (:SCIPgetNReoptnodes, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_NODE}), - scip, - node, - ) +function SCIPgetReoptChildIDs(scip, node, ids, idssize, nids) + ccall((:SCIPgetReoptChildIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}, Cint, Ptr{Cint}), scip, node, ids, idssize, nids) end -function SCIPgetNReoptLeaves(scip, node) - ccall( - (:SCIPgetNReoptLeaves, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_NODE}), - scip, - node, - ) +function SCIPgetReoptLeaveIDs(scip, node, ids, idssize, nids) + ccall((:SCIPgetReoptLeaveIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}, Cint, Ptr{Cint}), scip, node, ids, idssize, nids) end -function SCIPgetReoptnode(scip, id) - ccall( - (:SCIPgetReoptnode, libscip), - Ptr{SCIP_REOPTNODE}, - (Ptr{SCIP}, Cuint), - scip, - id, - ) +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}, Cuint), 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{Cuint}), - 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, - Cuint, - ), - scip, - reoptnode, - vars, - vals, - boundtypes, - lhs, - rhs, - nvars, - constype, - linear, - ) -end - -function SCIPgetReoptnodePath( - scip, - reoptnode, - vars, - vals, - boundtypes, - mem, - nvars, - nafterdualvars, -) - ccall( - (:SCIPgetReoptnodePath, libscip), - Cvoid, - ( - Ptr{SCIP}, - Ptr{SCIP_REOPTNODE}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{SCIP_BOUNDTYPE}, - Cint, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - reoptnode, - vars, - vals, - boundtypes, - mem, - nvars, - nafterdualvars, - ) + ccall((: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{Cuint}), 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, Cuint), 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, - ) + ccall((:SCIPinitRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) end function SCIPresetRepresentation(scip, representatives, nrepresentatives) - ccall( - (:SCIPresetRepresentation, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), - scip, - representatives, - nrepresentatives, - ) + ccall((:SCIPresetRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) end function SCIPfreeRepresentation(scip, representatives, nrepresentatives) - ccall( - (:SCIPfreeRepresentation, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), - scip, - representatives, - nrepresentatives, - ) -end - -function SCIPapplyReopt( - scip, - reoptnode, - id, - estimate, - childnodes, - ncreatedchilds, - naddedconss, - childnodessize, - success, -) - ccall( - (:SCIPapplyReopt, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_REOPTNODE}, - Cuint, - Cdouble, - Ptr{Ptr{SCIP_NODE}}, - Ptr{Cint}, - Ptr{Cint}, - Cint, - Ptr{Cuint}, - ), - scip, - reoptnode, - id, - estimate, - childnodes, - ncreatedchilds, - naddedconss, - childnodessize, - success, - ) + 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}, Cuint, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cuint}), scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) end function SCIPresetReoptnodeDualcons(scip, node) - ccall( - (:SCIPresetReoptnodeDualcons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}), - scip, - node, - ) + ccall((:SCIPresetReoptnodeDualcons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) end function SCIPsplitReoptRoot(scip, ncreatedchilds, naddedconss) - ccall( - (:SCIPsplitReoptRoot, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}), - scip, - ncreatedchilds, - naddedconss, - ) + ccall((:SCIPsplitReoptRoot, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}), scip, ncreatedchilds, naddedconss) end function SCIPreoptimizeNode(scip, node) - ccall( - (:SCIPreoptimizeNode, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_NODE}), - scip, - node, - ) + ccall((:SCIPreoptimizeNode, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) end function SCIPdeleteReoptnode(scip, reoptnode) - ccall( - (:SCIPdeleteReoptnode, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}), - scip, - reoptnode, - ) + ccall((:SCIPdeleteReoptnode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}), scip, reoptnode) end function SCIPgetReoptSimilarity(scip, run1, run2) - ccall( - (:SCIPgetReoptSimilarity, libscip), - Cdouble, - (Ptr{SCIP}, Cint, Cint), - scip, - run1, - run2, - ) -end - -function SCIPgetVarCoefChg(scip, varidx, negated, entering, leaving) - ccall( - (:SCIPgetVarCoefChg, libscip), - Cvoid, - (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), - scip, - varidx, - negated, - entering, - leaving, - ) -end - -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}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Cdouble, - Cuint, - Cuint, - 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}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Cdouble, - Cuint, - Cuint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_SEPADATA}, - ), - scip, - sepa, - name, - desc, - priority, - freq, - maxbounddist, - usessubscip, - delay, - sepaexeclp, - sepaexecsol, - sepadata, - ) + ccall((:SCIPgetReoptSimilarity, libscip), Cdouble, (Ptr{SCIP}, Cint, Cint), scip, run1, run2) +end + +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}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cdouble, Cuint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cdouble, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, sepa, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepaexeclp, sepaexecsol, sepadata) end function SCIPsetSepaCopy(scip, sepa, sepacopy) - ccall( - (:SCIPsetSepaCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), - scip, - sepa, - sepacopy, - ) + ccall((:SCIPsetSepaCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepacopy) end function SCIPsetSepaFree(scip, sepa, sepafree) - ccall( - (:SCIPsetSepaFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), - scip, - sepa, - sepafree, - ) + ccall((:SCIPsetSepaFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepafree) end function SCIPsetSepaInit(scip, sepa, sepainit) - ccall( - (:SCIPsetSepaInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), - scip, - sepa, - sepainit, - ) + ccall((:SCIPsetSepaInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainit) end function SCIPsetSepaExit(scip, sepa, sepaexit) - ccall( - (:SCIPsetSepaExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), - scip, - sepa, - sepaexit, - ) + ccall((:SCIPsetSepaExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexit) end function SCIPsetSepaInitsol(scip, sepa, sepainitsol) - ccall( - (:SCIPsetSepaInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), - scip, - sepa, - sepainitsol, - ) + ccall((:SCIPsetSepaInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainitsol) end function SCIPsetSepaExitsol(scip, sepa, sepaexitsol) - ccall( - (:SCIPsetSepaExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), - scip, - sepa, - sepaexitsol, - ) + ccall((:SCIPsetSepaExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexitsol) end function SCIPfindSepa(scip, name) - ccall( - (:SCIPfindSepa, libscip), - Ptr{SCIP_SEPA}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetSepas(scip) @@ -17615,192 +8034,55 @@ function SCIPgetNSepas(scip) end function SCIPsetSepaPriority(scip, sepa, priority) - ccall( - (:SCIPsetSepaPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SEPA}, Cint), - scip, - sepa, - priority, - ) + ccall((:SCIPsetSepaPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Cint), scip, sepa, priority) end function SCIPsetSepaIsParentsepa(scip, sepa) - ccall( - (:SCIPsetSepaIsParentsepa, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_SEPA}), - scip, - sepa, - ) + ccall((:SCIPsetSepaIsParentsepa, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SEPA}), scip, sepa) end function SCIPsetSepaParentsepa(scip, sepa, parentsepa) - ccall( - (:SCIPsetSepaParentsepa, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{SCIP_SEPA}), - scip, - sepa, - parentsepa, - ) + ccall((:SCIPsetSepaParentsepa, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{SCIP_SEPA}), scip, sepa, parentsepa) end function SCIPgetSepaMinEfficacy(scip) ccall((:SCIPgetSepaMinEfficacy, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPincludeCutsel( - scip, - name, - desc, - priority, - cutselcopy, - cutselfree, - cutselinit, - cutselexit, - cutselinitsol, - cutselexitsol, - cutselselect, - cutseldata, -) - ccall( - (:SCIPincludeCutsel, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_CUTSELDATA}, - ), - scip, - name, - desc, - priority, - cutselcopy, - cutselfree, - cutselinit, - cutselexit, - cutselinitsol, - cutselexitsol, - cutselselect, - cutseldata, - ) -end - -function SCIPincludeCutselBasic( - scip, - cutsel, - name, - desc, - priority, - cutselselect, - cutseldata, -) - ccall( - (:SCIPincludeCutselBasic, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CUTSEL}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Ptr{Cvoid}, - Ptr{SCIP_CUTSELDATA}, - ), - scip, - cutsel, - name, - desc, - priority, - cutselselect, - cutseldata, - ) +function SCIPincludeCutsel(scip, name, desc, priority, cutselcopy, cutselfree, cutselinit, cutselexit, cutselinitsol, cutselexitsol, cutselselect, cutseldata) + ccall((:SCIPincludeCutsel, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CUTSELDATA}), scip, name, desc, priority, cutselcopy, cutselfree, cutselinit, cutselexit, cutselinitsol, cutselexitsol, cutselselect, cutseldata) +end + +function SCIPincludeCutselBasic(scip, cutsel, name, desc, priority, cutselselect, cutseldata) + ccall((:SCIPincludeCutselBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTSEL}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{SCIP_CUTSELDATA}), scip, cutsel, name, desc, priority, cutselselect, cutseldata) end function SCIPsetCutselCopy(scip, cutsel, cutselcopy) - ccall( - (:SCIPsetCutselCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), - scip, - cutsel, - cutselcopy, - ) + ccall((:SCIPsetCutselCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselcopy) end function SCIPsetCutselFree(scip, cutsel, cutselfree) - ccall( - (:SCIPsetCutselFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), - scip, - cutsel, - cutselfree, - ) + ccall((:SCIPsetCutselFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselfree) end function SCIPsetCutselInit(scip, cutsel, cutselinit) - ccall( - (:SCIPsetCutselInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), - scip, - cutsel, - cutselinit, - ) + ccall((:SCIPsetCutselInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselinit) end function SCIPsetCutselExit(scip, cutsel, cutselexit) - ccall( - (:SCIPsetCutselExit, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), - scip, - cutsel, - cutselexit, - ) + ccall((:SCIPsetCutselExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselexit) end function SCIPsetCutselInitsol(scip, cutsel, cutselinitsol) - ccall( - (:SCIPsetCutselInitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), - scip, - cutsel, - cutselinitsol, - ) + ccall((:SCIPsetCutselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselinitsol) end function SCIPsetCutselExitsol(scip, cutsel, cutselexitsol) - ccall( - (:SCIPsetCutselExitsol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), - scip, - cutsel, - cutselexitsol, - ) + ccall((:SCIPsetCutselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselexitsol) end function SCIPfindCutsel(scip, name) - ccall( - (:SCIPfindCutsel, libscip), - Ptr{SCIP_CUTSEL}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindCutsel, libscip), Ptr{SCIP_CUTSEL}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetCutsels(scip) @@ -17812,480 +8094,215 @@ function SCIPgetNCutsels(scip) end function SCIPsetCutselPriority(scip, cutsel, priority) - ccall( - (:SCIPsetCutselPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Cint), - scip, - cutsel, - priority, - ) + ccall((:SCIPsetCutselPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Cint), scip, cutsel, priority) end function SCIPcreateSol(scip, sol, heur) - ccall( - (:SCIPcreateSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreateSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateSolExact(scip, sol, heur) + ccall((:SCIPcreateSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateLPSol(scip, sol, heur) - ccall( - (:SCIPcreateLPSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreateLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) +end + +function SCIPcreateLPSolExact(scip, sol, heur) + ccall((:SCIPcreateLPSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateNLPSol(scip, sol, heur) - ccall( - (:SCIPcreateNLPSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreateNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateRelaxSol(scip, sol, heur) - ccall( - (:SCIPcreateRelaxSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreateRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreatePseudoSol(scip, sol, heur) - ccall( - (:SCIPcreatePseudoSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreatePseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateCurrentSol(scip, sol, heur) - ccall( - (:SCIPcreateCurrentSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreateCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreatePartialSol(scip, sol, heur) - ccall( - (:SCIPcreatePartialSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreatePartialSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateUnknownSol(scip, sol, heur) - ccall( - (:SCIPcreateUnknownSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreateUnknownSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateOrigSol(scip, sol, heur) - ccall( - (:SCIPcreateOrigSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), - scip, - sol, - heur, - ) + ccall((:SCIPcreateOrigSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) end function SCIPcreateSolCopy(scip, sol, sourcesol) - ccall( - (:SCIPcreateSolCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), - scip, - sol, - sourcesol, - ) + ccall((:SCIPcreateSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) end function SCIPcreateSolCopyOrig(scip, sol, sourcesol) - ccall( - (:SCIPcreateSolCopyOrig, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), - scip, - sol, - sourcesol, - ) + ccall((:SCIPcreateSolCopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) end function SCIPcreateFiniteSolCopy(scip, sol, sourcesol, success) - ccall( - (:SCIPcreateFiniteSolCopy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}, Ptr{Cuint}), - scip, - sol, - sourcesol, - success, - ) + ccall((:SCIPcreateFiniteSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, sol, sourcesol, success) end function SCIPfreeSol(scip, sol) - ccall( - (:SCIPfreeSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}), - scip, - sol, - ) + ccall((:SCIPfreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}), scip, sol) end function SCIPlinkLPSol(scip, sol) - ccall( - (:SCIPlinkLPSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPlinkLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPlinkLPSolExact(scip, sol) + ccall((:SCIPlinkLPSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPlinkNLPSol(scip, sol) - ccall( - (:SCIPlinkNLPSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPlinkNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPlinkRelaxSol(scip, sol) - ccall( - (:SCIPlinkRelaxSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPlinkRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPlinkPseudoSol(scip, sol) - ccall( - (:SCIPlinkPseudoSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPlinkPseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPlinkCurrentSol(scip, sol) - ccall( - (:SCIPlinkCurrentSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPlinkCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPclearSol(scip, sol) - ccall( - (:SCIPclearSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPclearSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPunlinkSol(scip, sol) - ccall( - (:SCIPunlinkSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPunlinkSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPunlinkSolExact(scip, sol) + ccall((:SCIPunlinkSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPsetSolVal(scip, sol, var, val) - ccall( - (:SCIPsetSolVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), - scip, - sol, - var, - val, - ) + ccall((:SCIPsetSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, val) +end + +function SCIPsetSolValExact(scip, sol, var, val) + ccall((:SCIPsetSolValExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, sol, var, val) end function SCIPsetSolVals(scip, sol, nvars, vars, vals) - ccall( - (:SCIPsetSolVals, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), - scip, - sol, - nvars, - vars, - vals, - ) + ccall((:SCIPsetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) end function SCIPincSolVal(scip, sol, var, incval) - ccall( - (:SCIPincSolVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), - scip, - sol, - var, - incval, - ) + ccall((:SCIPincSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, incval) end function SCIPgetSolVal(scip, sol, var) - ccall( - (:SCIPgetSolVal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}), - scip, - sol, - var, - ) + ccall((:SCIPgetSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}), scip, sol, var) +end + +function SCIPgetSolValExact(scip, sol, var, res) + ccall((:SCIPgetSolValExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, sol, var, res) end function SCIPgetSolVals(scip, sol, nvars, vars, vals) - ccall( - (:SCIPgetSolVals, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), - scip, - sol, - nvars, - vars, - vals, - ) + ccall((:SCIPgetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) end function SCIPgetSolOrigObj(scip, sol) - ccall( - (:SCIPgetSolOrigObj, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPgetSolOrigObj, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPgetSolOrigObjExact(scip, sol, res) + ccall((:SCIPgetSolOrigObjExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, sol, res) end function SCIPgetSolTransObj(scip, sol) - ccall( - (:SCIPgetSolTransObj, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPgetSolTransObj, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPgetSolTransObjExact(scip, sol, res) + ccall((:SCIPgetSolTransObjExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, sol, res) end function SCIPrecomputeSolObj(scip, sol) - ccall( - (:SCIPrecomputeSolObj, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPrecomputeSolObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPtransformObj(scip, obj) - ccall( - (:SCIPtransformObj, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - obj, - ) + ccall((:SCIPtransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) end function SCIPretransformObj(scip, obj) - ccall( - (:SCIPretransformObj, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - obj, - ) + ccall((:SCIPretransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) end function SCIPgetSolTime(scip, sol) - ccall( - (:SCIPgetSolTime, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPgetSolTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPgetSolRunnum(scip, sol) - ccall( - (:SCIPgetSolRunnum, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPgetSolRunnum, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPgetSolNodenum(scip, sol) - ccall( - (:SCIPgetSolNodenum, libscip), - Clonglong, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPgetSolNodenum, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPgetSolHeur(scip, sol) - ccall( - (:SCIPgetSolHeur, libscip), - Ptr{SCIP_HEUR}, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPgetSolHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPareSolsEqual(scip, sol1, sol2) - ccall( - (:SCIPareSolsEqual, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_SOL}), - scip, - sol1, - sol2, - ) + ccall((:SCIPareSolsEqual, libscip), Cuint, (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}, Cuint), - scip, - sol, - uselprows, - ) + ccall((:SCIPadjustImplicitSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint), scip, sol, uselprows) end function SCIPprintSol(scip, sol, file, printzeros) - ccall( - (:SCIPprintSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), - scip, - sol, - file, - printzeros, - ) + ccall((:SCIPprintSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), scip, sol, file, printzeros) +end + +function SCIPprintSolExact(scip, sol, file, printzeros) + ccall((:SCIPprintSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), scip, sol, file, printzeros) end function SCIPprintTransSol(scip, sol, file, printzeros) - ccall( - (:SCIPprintTransSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), - scip, - sol, - file, - printzeros, - ) + ccall((:SCIPprintTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), scip, sol, file, printzeros) end function SCIPprintMIPStart(scip, sol, file) - ccall( - (:SCIPprintMIPStart, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), - scip, - sol, - file, - ) + ccall((:SCIPprintMIPStart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), scip, sol, file) end function SCIPgetDualSolVal(scip, cons, dualsolval, boundconstraint) - ccall( - (:SCIPgetDualSolVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), - scip, - cons, - dualsolval, - boundconstraint, - ) + ccall((:SCIPgetDualSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), scip, cons, dualsolval, boundconstraint) end function SCIPisDualSolAvailable(scip, printreason) - ccall( - (:SCIPisDualSolAvailable, libscip), - Cuint, - (Ptr{SCIP}, Cuint), - scip, - printreason, - ) + ccall((:SCIPisDualSolAvailable, libscip), Cuint, (Ptr{SCIP}, Cuint), scip, printreason) end function SCIPprintDualSol(scip, file, printzeros) - ccall( - (:SCIPprintDualSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), - scip, - file, - printzeros, - ) + ccall((:SCIPprintDualSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), scip, file, printzeros) end function SCIPprintRay(scip, sol, file, printzeros) - ccall( - (:SCIPprintRay, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), - scip, - sol, - file, - printzeros, - ) + ccall((:SCIPprintRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), scip, sol, file, printzeros) end function SCIPgetNSols(scip) @@ -18301,331 +8318,103 @@ function SCIPgetBestSol(scip) end function SCIPprintBestSol(scip, file, printzeros) - ccall( - (:SCIPprintBestSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), - scip, - file, - printzeros, - ) + ccall((:SCIPprintBestSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), scip, file, printzeros) end function SCIPprintBestTransSol(scip, file, printzeros) - ccall( - (:SCIPprintBestTransSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), - scip, - file, - printzeros, - ) + ccall((:SCIPprintBestTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), scip, file, printzeros) end function SCIProundSol(scip, sol, success) - ccall( - (:SCIProundSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}), - scip, - sol, - success, - ) + ccall((:SCIProundSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, sol, success) +end + +function SCIPmakeSolExact(scip, sol) + ccall((:SCIPmakeSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPretransformSol(scip, sol) - ccall( - (:SCIPretransformSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) + ccall((:SCIPretransformSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPretransformSolExact(scip, sol) + ccall((:SCIPretransformSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) end function SCIPreadSol(scip, filename) - ccall( - (:SCIPreadSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - filename, - ) + ccall((:SCIPreadSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) end function SCIPreadSolFile(scip, filename, sol, xml, partial, error) - ccall( - (:SCIPreadSolFile, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_SOL}, Cuint, Ptr{Cuint}, Ptr{Cuint}), - scip, - filename, - sol, - xml, - partial, - error, - ) + ccall((:SCIPreadSolFile, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_SOL}, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, filename, sol, xml, partial, error) end function SCIPaddSol(scip, sol, stored) - ccall( - (:SCIPaddSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}), - scip, - sol, - stored, - ) + ccall((:SCIPaddSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, sol, stored) end function SCIPaddSolFree(scip, sol, stored) - ccall( - (:SCIPaddSolFree, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{Cuint}), - scip, - sol, - stored, - ) + ccall((:SCIPaddSolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{Cuint}), scip, sol, stored) end function SCIPaddCurrentSol(scip, heur, stored) - ccall( - (:SCIPaddCurrentSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cuint}), - scip, - heur, - stored, - ) -end - -function SCIPtrySol( - scip, - sol, - printreason, - completely, - checkbounds, - checkintegrality, - checklprows, - stored, -) - ccall( - (:SCIPtrySol, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_SOL}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - 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}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - 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}, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), - scip, - heur, - printreason, - completely, - checkintegrality, - checklprows, - stored, - ) + ccall((:SCIPaddCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cuint}), scip, heur, stored) +end + +function SCIPtrySol(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) + ccall((:SCIPtrySol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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}}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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}, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), scip, heur, printreason, completely, checkintegrality, checklprows, stored) end function SCIPgetPartialSols(scip) - ccall( - (:SCIPgetPartialSols, libscip), - Ptr{Ptr{SCIP_SOL}}, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetPartialSols, libscip), Ptr{Ptr{SCIP_SOL}}, (Ptr{SCIP},), scip) end function SCIPgetNPartialSols(scip) ccall((:SCIPgetNPartialSols, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPcheckSol( - scip, - sol, - printreason, - completely, - checkbounds, - checkintegrality, - checklprows, - feasible, -) - ccall( - (:SCIPcheckSol, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_SOL}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - scip, - sol, - printreason, - completely, - checkbounds, - checkintegrality, - checklprows, - feasible, - ) +function SCIPcheckSol(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) + ccall((:SCIPcheckSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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{Cuint}, Cuint, Cuint), - scip, - sol, - feasible, - printreason, - completely, - ) + ccall((:SCIPcheckSolOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}, Cuint, Cuint), scip, sol, feasible, printreason, completely) end function SCIPupdateSolIntegralityViolation(scip, sol, absviol) - ccall( - (:SCIPupdateSolIntegralityViolation, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble), - scip, - sol, - absviol, - ) + ccall((:SCIPupdateSolIntegralityViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble), scip, sol, absviol) end function SCIPupdateSolBoundViolation(scip, sol, absviol, relviol) - ccall( - (:SCIPupdateSolBoundViolation, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), - scip, - sol, - absviol, - relviol, - ) + ccall((:SCIPupdateSolBoundViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end function SCIPupdateSolLPRowViolation(scip, sol, absviol, relviol) - ccall( - (:SCIPupdateSolLPRowViolation, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), - scip, - sol, - absviol, - relviol, - ) + ccall((:SCIPupdateSolLPRowViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end function SCIPupdateSolConsViolation(scip, sol, absviol, relviol) - ccall( - (:SCIPupdateSolConsViolation, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), - scip, - sol, - absviol, - relviol, - ) + ccall((:SCIPupdateSolConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end function SCIPupdateSolLPConsViolation(scip, sol, absviol, relviol) - ccall( - (:SCIPupdateSolLPConsViolation, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), - scip, - sol, - absviol, - relviol, - ) + ccall((:SCIPupdateSolLPConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) end function SCIPactivateSolViolationUpdates(scip) - ccall( - (:SCIPactivateSolViolationUpdates, libscip), - Cvoid, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP},), scip) end function SCIPdeactivateSolViolationUpdates(scip) - ccall( - (:SCIPdeactivateSolViolationUpdates, libscip), - Cvoid, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPdeactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP},), scip) end function SCIPhasPrimalRay(scip) @@ -18633,23 +8422,19 @@ function SCIPhasPrimalRay(scip) end function SCIPgetPrimalRayVal(scip, var) - ccall( - (:SCIPgetPrimalRayVal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetPrimalRayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPupdatePrimalRay(scip, primalray) - ccall( - (:SCIPupdatePrimalRay, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - primalray, - ) + ccall((:SCIPupdatePrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, primalray) +end + +function SCIPoverwriteFPsol(scip, sol) + ccall((:SCIPoverwriteFPsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPtrySolFreeExact(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) + ccall((:SCIPtrySolFreeExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) end function SCIPtransformProb(scip) @@ -18664,22 +8449,12 @@ 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}, Cuint), - scip, - restart, - ) + ccall((:SCIPfreeSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, restart) end function SCIPfreeTransform(scip) @@ -18707,30 +8482,15 @@ function SCIPfreeReoptSolve(scip) end function SCIPenableReoptimization(scip, enable) - ccall( - (:SCIPenableReoptimization, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint), - scip, - enable, - ) + ccall((:SCIPenableReoptimization, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, enable) end function SCIPisReoptEnabled(scip) ccall((:SCIPisReoptEnabled, libscip), Cuint, (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, - ) +function SCIPgetReoptSolsRun(scip, run, sols, solssize, nsols) + ccall((:SCIPgetReoptSolsRun, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_SOL}}, Cint, Ptr{Cint}), scip, run, sols, solssize, nsols) end function SCIPresetReoptSolMarks(scip) @@ -18738,27 +8498,11 @@ function SCIPresetReoptSolMarks(scip) end function SCIPcheckReoptRestart(scip, node, restart) - ccall( - (:SCIPcheckReoptRestart, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}), - scip, - node, - restart, - ) + ccall((:SCIPcheckReoptRestart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}), scip, node, restart) end function SCIPaddReoptDualBndchg(scip, node, var, newbound, oldbound) - ccall( - (:SCIPaddReoptDualBndchg, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble, Cdouble), - scip, - node, - var, - newbound, - oldbound, - ) + ccall((:SCIPaddReoptDualBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, node, var, newbound, oldbound) end function SCIPgetReoptLastOptSol(scip) @@ -18766,15 +8510,7 @@ function SCIPgetReoptLastOptSol(scip) end function SCIPgetReoptOldObjCoef(scip, var, run, objcoef) - ccall( - (:SCIPgetReoptOldObjCoef, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), - scip, - var, - run, - objcoef, - ) + ccall((:SCIPgetReoptOldObjCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, run, objcoef) end function SCIPgetNRuns(scip) @@ -18786,13 +8522,7 @@ function SCIPgetNReoptRuns(scip) end function SCIPaddNNodes(scip, nnodes) - ccall( - (:SCIPaddNNodes, libscip), - Cvoid, - (Ptr{SCIP}, Clonglong), - scip, - nnodes, - ) + ccall((:SCIPaddNNodes, libscip), Cvoid, (Ptr{SCIP}, Clonglong), scip, nnodes) end function SCIPgetNNodes(scip) @@ -18823,6 +8553,10 @@ function SCIPgetNRootboundChgsRun(scip) ccall((:SCIPgetNRootboundChgsRun, libscip), Cint, (Ptr{SCIP},), scip) end +function SCIPgetNRootIntFixingsRun(scip) + ccall((:SCIPgetNRootIntFixingsRun, libscip), Cint, (Ptr{SCIP},), scip) +end + function SCIPgetNDelayedCutoffs(scip) ccall((:SCIPgetNDelayedCutoffs, libscip), Clonglong, (Ptr{SCIP},), scip) end @@ -18831,6 +8565,10 @@ function SCIPgetNLPs(scip) ccall((:SCIPgetNLPs, libscip), Clonglong, (Ptr{SCIP},), scip) end +function SCIPgetNExactLPs(scip) + ccall((:SCIPgetNExactLPs, libscip), Clonglong, (Ptr{SCIP},), scip) +end + function SCIPgetNLPIterations(scip) ccall((:SCIPgetNLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end @@ -18844,12 +8582,7 @@ function SCIPgetNRootLPIterations(scip) end function SCIPgetNRootFirstLPIterations(scip) - ccall( - (:SCIPgetNRootFirstLPIterations, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNRootFirstLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNPrimalLPs(scip) @@ -18873,12 +8606,7 @@ function SCIPgetNBarrierLPs(scip) end function SCIPgetNBarrierLPIterations(scip) - ccall( - (:SCIPgetNBarrierLPIterations, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNBarrierLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNResolveLPs(scip) @@ -18886,12 +8614,7 @@ function SCIPgetNResolveLPs(scip) end function SCIPgetNResolveLPIterations(scip) - ccall( - (:SCIPgetNResolveLPIterations, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNPrimalResolveLPs(scip) @@ -18899,12 +8622,7 @@ function SCIPgetNPrimalResolveLPs(scip) end function SCIPgetNPrimalResolveLPIterations(scip) - ccall( - (:SCIPgetNPrimalResolveLPIterations, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNPrimalResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNDualResolveLPs(scip) @@ -18912,12 +8630,7 @@ function SCIPgetNDualResolveLPs(scip) end function SCIPgetNDualResolveLPIterations(scip) - ccall( - (:SCIPgetNDualResolveLPIterations, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNDualResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNNodeLPs(scip) @@ -18925,12 +8638,7 @@ function SCIPgetNNodeLPs(scip) end function SCIPgetNNodeZeroIterationLPs(scip) - ccall( - (:SCIPgetNNodeZeroIterationLPs, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNNodeZeroIterationLPs, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNNodeLPIterations(scip) @@ -18942,12 +8650,7 @@ function SCIPgetNNodeInitLPs(scip) end function SCIPgetNNodeInitLPIterations(scip) - ccall( - (:SCIPgetNNodeInitLPIterations, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNNodeInitLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNDivingLPs(scip) @@ -18963,12 +8666,7 @@ function SCIPgetNStrongbranchs(scip) end function SCIPgetNStrongbranchLPIterations(scip) - ccall( - (:SCIPgetNStrongbranchLPIterations, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNRootStrongbranchs(scip) @@ -18976,12 +8674,7 @@ function SCIPgetNRootStrongbranchs(scip) end function SCIPgetNRootStrongbranchLPIterations(scip) - ccall( - (:SCIPgetNRootStrongbranchLPIterations, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNRootStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNPriceRounds(scip) @@ -19025,21 +8718,15 @@ function SCIPgetNConflictConssFoundNode(scip) end function SCIPgetNConflictConssApplied(scip) - ccall( - (:SCIPgetNConflictConssApplied, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNConflictConssApplied, libscip), Clonglong, (Ptr{SCIP},), scip) +end + +function SCIPgetNResConflictConssApplied(scip) + ccall((:SCIPgetNResConflictConssApplied, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetNConflictDualproofsApplied(scip) - ccall( - (:SCIPgetNConflictDualproofsApplied, libscip), - Clonglong, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetNConflictDualproofsApplied, libscip), Clonglong, (Ptr{SCIP},), scip) end function SCIPgetMaxDepth(scip) @@ -19074,10 +8761,18 @@ function SCIPgetDualbound(scip) ccall((:SCIPgetDualbound, libscip), Cdouble, (Ptr{SCIP},), scip) end +function SCIPgetDualboundExact(scip, result) + ccall((:SCIPgetDualboundExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) +end + function SCIPgetLowerbound(scip) ccall((:SCIPgetLowerbound, libscip), Cdouble, (Ptr{SCIP},), scip) end +function SCIPgetLowerboundExact(scip, result) + ccall((:SCIPgetLowerboundExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) +end + function SCIPgetDualboundRoot(scip) ccall((:SCIPgetDualboundRoot, libscip), Cdouble, (Ptr{SCIP},), scip) end @@ -19102,22 +8797,28 @@ function SCIPgetPrimalbound(scip) ccall((:SCIPgetPrimalbound, libscip), Cdouble, (Ptr{SCIP},), scip) end +function SCIPgetPrimalboundExact(scip, result) + ccall((:SCIPgetPrimalboundExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) +end + function SCIPgetUpperbound(scip) ccall((:SCIPgetUpperbound, libscip), Cdouble, (Ptr{SCIP},), scip) end +function SCIPgetUpperboundExact(scip, result) + ccall((:SCIPgetUpperboundExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) +end + function SCIPgetCutoffbound(scip) ccall((:SCIPgetCutoffbound, libscip), Cdouble, (Ptr{SCIP},), scip) end +function SCIPgetCutoffboundExact(scip) + ccall((:SCIPgetCutoffboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP},), scip) +end + function SCIPupdateCutoffbound(scip, cutoffbound) - ccall( - (:SCIPupdateCutoffbound, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cdouble), - scip, - cutoffbound, - ) + ccall((:SCIPupdateCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, cutoffbound) end function SCIPisPrimalboundSol(scip) @@ -19145,78 +8846,39 @@ function SCIPgetNBestSolsFound(scip) end function SCIPgetAvgPseudocost(scip, solvaldelta) - ccall( - (:SCIPgetAvgPseudocost, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - solvaldelta, - ) + ccall((:SCIPgetAvgPseudocost, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) end function SCIPgetAvgPseudocostCurrentRun(scip, solvaldelta) - ccall( - (:SCIPgetAvgPseudocostCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble), - scip, - solvaldelta, - ) + ccall((:SCIPgetAvgPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) end function SCIPgetAvgPseudocostCount(scip, dir) - ccall( - (:SCIPgetAvgPseudocostCount, libscip), - Cdouble, - (Ptr{SCIP}, SCIP_BRANCHDIR), - scip, - dir, - ) + ccall((:SCIPgetAvgPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgPseudocostCountCurrentRun(scip, dir) - ccall( - (:SCIPgetAvgPseudocostCountCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, SCIP_BRANCHDIR), - scip, - dir, - ) + ccall((:SCIPgetAvgPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetPseudocostCount(scip, dir, onlycurrentrun) - ccall( - (:SCIPgetPseudocostCount, libscip), - Cdouble, - (Ptr{SCIP}, SCIP_BRANCHDIR, Cuint), - scip, - dir, - onlycurrentrun, - ) + ccall((:SCIPgetPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, Cuint), scip, dir, onlycurrentrun) end function SCIPgetAvgPseudocostScore(scip) ccall((:SCIPgetAvgPseudocostScore, libscip), Cdouble, (Ptr{SCIP},), scip) end +function SCIPgetAvgDPseudocostScore(scip, discountfac) + ccall((:SCIPgetAvgDPseudocostScore, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, discountfac) +end + function SCIPgetPseudocostVariance(scip, branchdir, onlycurrentrun) - ccall( - (:SCIPgetPseudocostVariance, libscip), - Cdouble, - (Ptr{SCIP}, SCIP_BRANCHDIR, Cuint), - scip, - branchdir, - onlycurrentrun, - ) + ccall((:SCIPgetPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, Cuint), scip, branchdir, onlycurrentrun) end function SCIPgetAvgPseudocostScoreCurrentRun(scip) - ccall( - (:SCIPgetAvgPseudocostScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetAvgPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) end function SCIPgetAvgConflictScore(scip) @@ -19224,50 +8886,23 @@ function SCIPgetAvgConflictScore(scip) end function SCIPgetAvgConflictScoreCurrentRun(scip) - ccall( - (:SCIPgetAvgConflictScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetAvgConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) end function SCIPgetAvgConflictlengthScore(scip) - ccall( - (:SCIPgetAvgConflictlengthScore, libscip), - Cdouble, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetAvgConflictlengthScore, libscip), Cdouble, (Ptr{SCIP},), scip) end function SCIPgetAvgConflictlengthScoreCurrentRun(scip) - ccall( - (:SCIPgetAvgConflictlengthScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetAvgConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) end function SCIPgetAvgInferences(scip, dir) - ccall( - (:SCIPgetAvgInferences, libscip), - Cdouble, - (Ptr{SCIP}, SCIP_BRANCHDIR), - scip, - dir, - ) + ccall((:SCIPgetAvgInferences, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgInferencesCurrentRun(scip, dir) - ccall( - (:SCIPgetAvgInferencesCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, SCIP_BRANCHDIR), - scip, - dir, - ) + ccall((:SCIPgetAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgInferenceScore(scip) @@ -19275,32 +8910,15 @@ function SCIPgetAvgInferenceScore(scip) end function SCIPgetAvgInferenceScoreCurrentRun(scip) - ccall( - (:SCIPgetAvgInferenceScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) end function SCIPgetAvgCutoffs(scip, dir) - ccall( - (:SCIPgetAvgCutoffs, libscip), - Cdouble, - (Ptr{SCIP}, SCIP_BRANCHDIR), - scip, - dir, - ) + ccall((:SCIPgetAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgCutoffsCurrentRun(scip, dir) - ccall( - (:SCIPgetAvgCutoffsCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, SCIP_BRANCHDIR), - scip, - dir, - ) + ccall((:SCIPgetAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) end function SCIPgetAvgCutoffScore(scip) @@ -19308,412 +8926,263 @@ function SCIPgetAvgCutoffScore(scip) end function SCIPgetAvgCutoffScoreCurrentRun(scip) - ccall( - (:SCIPgetAvgCutoffScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPgetAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPgetDeterministicTime(scip) - ccall((:SCIPgetDeterministicTime, libscip), Cdouble, (Ptr{SCIP},), scip) +function SCIPgetAvgGMIeff(scip) + ccall((:SCIPgetAvgGMIeff, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPprintOrigProblem(scip, file, extension, genericnames) - ccall( - (:SCIPprintOrigProblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint), - scip, - file, - extension, - genericnames, - ) +function SCIPincAvgGMIeff(scip, gmieff) + ccall((:SCIPincAvgGMIeff, libscip), Cvoid, (Ptr{SCIP}, Cdouble), scip, gmieff) end -function SCIPprintTransProblem(scip, file, extension, genericnames) - ccall( - (:SCIPprintTransProblem, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint), - scip, - file, - extension, - genericnames, - ) +function SCIPgetDeterministicTime(scip) + ccall((:SCIPgetDeterministicTime, libscip), Cdouble, (Ptr{SCIP},), scip) end function SCIPprintStatusStatistics(scip, file) - ccall( - (:SCIPprintStatusStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintStatusStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectStatusStatistics(scip, datatree) + ccall((:SCIPcollectStatusStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintTimingStatistics(scip, file) - ccall( - (:SCIPprintTimingStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintTimingStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectTimingStatistics(scip, datatree) + ccall((:SCIPcollectTimingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintOrigProblemStatistics(scip, file) - ccall( - (:SCIPprintOrigProblemStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintOrigProblemStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectOrigProblemStatistics(scip, datatree) + ccall((:SCIPcollectOrigProblemStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintTransProblemStatistics(scip, file) - ccall( - (:SCIPprintTransProblemStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintTransProblemStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectTransProblemStatistics(scip, datatree) + ccall((:SCIPcollectTransProblemStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintPresolverStatistics(scip, file) - ccall( - (:SCIPprintPresolverStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintPresolverStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectPresolverStatistics(scip, datatree) + ccall((:SCIPcollectPresolverStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintConstraintStatistics(scip, file) - ccall( - (:SCIPprintConstraintStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintConstraintStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectConstraintStatistics(scip, datatree) + ccall((:SCIPcollectConstraintStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintConstraintTimingStatistics(scip, file) - ccall( - (:SCIPprintConstraintTimingStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintConstraintTimingStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectConstraintTimingStatistics(scip, datatree) + ccall((:SCIPcollectConstraintTimingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintPropagatorStatistics(scip, file) - ccall( - (:SCIPprintPropagatorStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintPropagatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectPropagatorStatistics(scip, datatree) + ccall((:SCIPcollectPropagatorStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintConflictStatistics(scip, file) - ccall( - (:SCIPprintConflictStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintConflictStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectConflictStatistics(scip, datatree) + ccall((:SCIPcollectConflictStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintSeparatorStatistics(scip, file) - ccall( - (:SCIPprintSeparatorStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintSeparatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectSeparatorStatistics(scip, datatree) + ccall((:SCIPcollectSeparatorStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintCutselectorStatistics(scip, file) - ccall( - (:SCIPprintCutselectorStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintCutselectorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectCutselectorStatistics(scip, datatree) + ccall((:SCIPcollectCutselectorStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintPricerStatistics(scip, file) - ccall( - (:SCIPprintPricerStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintPricerStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectPricerStatistics(scip, datatree) + ccall((:SCIPcollectPricerStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintBranchruleStatistics(scip, file) - ccall( - (:SCIPprintBranchruleStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintBranchruleStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectBranchruleStatistics(scip, datatree) + ccall((:SCIPcollectBranchruleStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintHeuristicStatistics(scip, file) - ccall( - (:SCIPprintHeuristicStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintHeuristicStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectHeuristicStatistics(scip, datatree) + ccall((:SCIPcollectHeuristicStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintCompressionStatistics(scip, file) - ccall( - (:SCIPprintCompressionStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintCompressionStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectCompressionStatistics(scip, datatree) + ccall((:SCIPcollectCompressionStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintLPStatistics(scip, file) - ccall( - (:SCIPprintLPStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintLPStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectLPStatistics(scip, datatree) + ccall((:SCIPcollectLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintNLPStatistics(scip, file) - ccall( - (:SCIPprintNLPStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintNLPStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectNLPStatistics(scip, datatree) + ccall((:SCIPcollectNLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintRelaxatorStatistics(scip, file) - ccall( - (:SCIPprintRelaxatorStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintRelaxatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectRelaxatorStatistics(scip, datatree) + ccall((:SCIPcollectRelaxatorStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintTreeStatistics(scip, file) - ccall( - (:SCIPprintTreeStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintTreeStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectTreeStatistics(scip, datatree) + ccall((:SCIPcollectTreeStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintRootStatistics(scip, file) - ccall( - (:SCIPprintRootStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintRootStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectRootStatistics(scip, datatree) + ccall((:SCIPcollectRootStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintSolutionStatistics(scip, file) - ccall( - (:SCIPprintSolutionStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintSolutionStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectSolutionStatistics(scip, datatree) + ccall((:SCIPcollectSolutionStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintConcsolverStatistics(scip, file) - ccall( - (:SCIPprintConcsolverStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintConcsolverStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectConcsolverStatistics(scip, datatree) + ccall((:SCIPcollectConcsolverStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintBendersStatistics(scip, file) - ccall( - (:SCIPprintBendersStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintBendersStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectBendersStatistics(scip, datatree) + ccall((:SCIPcollectBendersStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintExpressionHandlerStatistics(scip, file) - ccall( - (:SCIPprintExpressionHandlerStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintExpressionHandlerStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectExpressionHandlerStatistics(scip, datatree) + ccall((:SCIPcollectExpressionHandlerStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintNLPIStatistics(scip, file) - ccall( - (:SCIPprintNLPIStatistics, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintNLPIStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectNLPIStatistics(scip, datatree) + ccall((:SCIPcollectNLPIStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintStatistics(scip, file) - ccall( - (:SCIPprintStatistics, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPprintStatisticsJson(scip, file) + ccall((:SCIPprintStatisticsJson, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) end function SCIPprintReoptStatistics(scip, file) - ccall( - (:SCIPprintReoptStatistics, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintReoptStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) end function SCIPprintBranchingStatistics(scip, file) - ccall( - (:SCIPprintBranchingStatistics, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}), - scip, - file, - ) + ccall((:SCIPprintBranchingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) +end + +function SCIPcollectBranchingStatistics(scip, datatree) + ccall((:SCIPcollectBranchingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) end function SCIPprintDisplayLine(scip, file, verblevel, endline) - ccall( - (:SCIPprintDisplayLine, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, SCIP_VERBLEVEL, Cuint), - scip, - file, - verblevel, - endline, - ) + ccall((:SCIPprintDisplayLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, SCIP_VERBLEVEL, Cuint), 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}, Ptr{Cchar}), - scip, - filename, - ) -end - function SCIPstoreSolutionGap(scip) ccall((:SCIPstoreSolutionGap, libscip), Cvoid, (Ptr{SCIP},), scip) end -function SCIPincludeTable( - scip, - name, - desc, - active, - tablecopy, - tablefree, - tableinit, - tableexit, - tableinitsol, - tableexitsol, - tableoutput, - tabledata, - position, - earlieststage, -) - ccall( - (:SCIPincludeTable, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Cchar}, - Cuint, - 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, - ) +function SCIPgetPrimalDualIntegral(scip) + ccall((:SCIPgetPrimalDualIntegral, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPincludeTable(scip, name, desc, active, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tablecollect, tabledata, position, earlieststage) + ccall((:SCIPincludeTable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Ptr{Cvoid}, 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, tablecollect, tabledata, position, earlieststage) end function SCIPfindTable(scip, name) - ccall( - (:SCIPfindTable, libscip), - Ptr{SCIP_TABLE}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - name, - ) + ccall((:SCIPfindTable, libscip), Ptr{SCIP_TABLE}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) end function SCIPgetTables(scip) @@ -19729,92 +9198,39 @@ function SCIPgetTimeOfDay(scip) end function SCIPcreateClock(scip, clck) - ccall( - (:SCIPcreateClock, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), - scip, - clck, - ) + ccall((:SCIPcreateClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) end function SCIPcreateCPUClock(scip, clck) - ccall( - (:SCIPcreateCPUClock, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), - scip, - clck, - ) + ccall((:SCIPcreateCPUClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) end function SCIPcreateWallClock(scip, clck) - ccall( - (:SCIPcreateWallClock, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), - scip, - clck, - ) + ccall((:SCIPcreateWallClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) end function SCIPfreeClock(scip, clck) - ccall( - (:SCIPfreeClock, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), - scip, - clck, - ) + ccall((:SCIPfreeClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) end function SCIPresetClock(scip, clck) - ccall( - (:SCIPresetClock, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CLOCK}), - scip, - clck, - ) + ccall((:SCIPresetClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) end function SCIPstartClock(scip, clck) - ccall( - (:SCIPstartClock, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CLOCK}), - scip, - clck, - ) + ccall((:SCIPstartClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) end function SCIPstopClock(scip, clck) - ccall( - (:SCIPstopClock, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CLOCK}), - scip, - clck, - ) + ccall((:SCIPstopClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) end function SCIPsetClockEnabled(clck, enable) - ccall( - (:SCIPsetClockEnabled, libscip), - Cvoid, - (Ptr{SCIP_CLOCK}, Cuint), - clck, - enable, - ) + ccall((:SCIPsetClockEnabled, libscip), Cvoid, (Ptr{SCIP_CLOCK}, Cuint), clck, enable) end function SCIPenableOrDisableStatisticTiming(scip) - ccall( - (:SCIPenableOrDisableStatisticTiming, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPenableOrDisableStatisticTiming, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPstartSolvingTime(scip) @@ -19826,24 +9242,11 @@ function SCIPstopSolvingTime(scip) end function SCIPgetClockTime(scip, clck) - ccall( - (:SCIPgetClockTime, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CLOCK}), - scip, - clck, - ) + ccall((:SCIPgetClockTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) end function SCIPsetClockTime(scip, clck, sec) - ccall( - (:SCIPsetClockTime, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CLOCK}, Cdouble), - scip, - clck, - sec, - ) + ccall((:SCIPsetClockTime, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}, Cdouble), scip, clck, sec) end function SCIPgetTotalTime(scip) @@ -19899,14 +9302,7 @@ function SCIPinRepropagation(scip) end function SCIPgetChildren(scip, children, nchildren) - ccall( - (:SCIPgetChildren, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), - scip, - children, - nchildren, - ) + ccall((:SCIPgetChildren, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, children, nchildren) end function SCIPgetNChildren(scip) @@ -19914,14 +9310,7 @@ function SCIPgetNChildren(scip) end function SCIPgetSiblings(scip, siblings, nsiblings) - ccall( - (:SCIPgetSiblings, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), - scip, - siblings, - nsiblings, - ) + ccall((:SCIPgetSiblings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, siblings, nsiblings) end function SCIPgetNSiblings(scip) @@ -19929,14 +9318,7 @@ function SCIPgetNSiblings(scip) end function SCIPgetLeaves(scip, leaves, nleaves) - ccall( - (:SCIPgetLeaves, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), - scip, - leaves, - nleaves, - ) + ccall((:SCIPgetLeaves, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, leaves, nleaves) end function SCIPgetNLeaves(scip) @@ -19975,45 +9357,12 @@ 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, - ) +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, - ) + ccall((:SCIPcutoffNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) end function SCIPpruneTree(scip) @@ -20021,13 +9370,7 @@ function SCIPpruneTree(scip) end function SCIPrepropagateNode(scip, node) - ccall( - (:SCIPrepropagateNode, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}), - scip, - node, - ) + ccall((:SCIPrepropagateNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) end function SCIPgetCutoffdepth(scip) @@ -20039,772 +9382,207 @@ function SCIPgetRepropdepth(scip) end function SCIPprintNodeRootPath(scip, node, file) - ccall( - (:SCIPprintNodeRootPath, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Libc.FILE}), - scip, - node, - file, - ) + ccall((:SCIPprintNodeRootPath, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Libc.FILE}), scip, node, file) end function SCIPsetFocusnodeLP(scip, solvelp) - ccall( - (:SCIPsetFocusnodeLP, libscip), - Cvoid, - (Ptr{SCIP}, Cuint), - scip, - solvelp, - ) + ccall((:SCIPsetFocusnodeLP, libscip), Cvoid, (Ptr{SCIP}, Cuint), scip, solvelp) end function SCIPwasNodeLastBranchParent(scip, node) - ccall( - (:SCIPwasNodeLastBranchParent, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_NODE}), - scip, - node, - ) -end - -function SCIPvalidateSolve( - scip, - primalreference, - dualreference, - reftol, - quiet, - feasible, - primalboundcheck, - dualboundcheck, -) - ccall( - (:SCIPvalidateSolve, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Cdouble, - Cdouble, - Cdouble, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - primalreference, - dualreference, - reftol, - quiet, - feasible, - primalboundcheck, - dualboundcheck, - ) -end - -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}}, - Ptr{Cchar}, - Cdouble, - Cdouble, - Cdouble, - SCIP_VARTYPE, - Cuint, - Cuint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_VARDATA}, - ), - scip, - var, - name, - lb, - ub, - obj, - vartype, - initial, - removable, - vardelorig, - vartrans, - vardeltrans, - varcopy, - vardata, - ) + ccall((:SCIPwasNodeLastBranchParent, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) +end + +function SCIPvalidateSolve(scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) + ccall((:SCIPvalidateSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) +end + +function SCIPvalidateSolveExact(scip, primalreference, dualreference, quiet, feasible, primalboundcheck, dualboundcheck) + ccall((:SCIPvalidateSolveExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, primalreference, dualreference, quiet, feasible, primalboundcheck, dualboundcheck) +end + +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}}, Ptr{Cchar}, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE, Cuint, Cuint, 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}}, - Ptr{Cchar}, - Cdouble, - Cdouble, - Cdouble, - SCIP_VARTYPE, - ), - scip, - var, - name, - lb, - ub, - obj, - vartype, - ) + ccall((:SCIPcreateVarBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cchar}, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE), scip, var, name, lb, ub, obj, vartype) +end + +function SCIPcreateVarImpl(scip, var, name, lb, ub, obj, vartype, impltype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) + ccall((:SCIPcreateVarImpl, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cchar}, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE, SCIP_IMPLINTTYPE, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}), scip, var, name, lb, ub, obj, vartype, impltype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) +end + +function SCIPaddVarExactData(scip, var, lb, ub, obj) + ccall((:SCIPaddVarExactData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), scip, var, lb, ub, obj) end function SCIPwriteVarName(scip, file, var, type) - ccall( - (:SCIPwriteVarName, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_VAR}, Cuint), - scip, - file, - var, - type, - ) + ccall((:SCIPwriteVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_VAR}, Cuint), scip, file, var, type) end function SCIPwriteVarsList(scip, file, vars, nvars, type, delimiter) - ccall( - (:SCIPwriteVarsList, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cchar), - scip, - file, - vars, - nvars, - type, - delimiter, - ) + ccall((:SCIPwriteVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cchar), scip, file, vars, nvars, type, delimiter) end function SCIPwriteVarsLinearsum(scip, file, vars, vals, nvars, type) - ccall( - (:SCIPwriteVarsLinearsum, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cint, - Cuint, - ), - 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{Libc.FILE}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Cdouble}, - Ptr{Cint}, - Cint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cuint, - Cuint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_VARDATA}, - Ptr{Ptr{Cchar}}, - Ptr{Cuint}, - ), - scip, - var, - str, - initial, - removable, - varcopy, - vardelorig, - vartrans, - vardeltrans, - vardata, - endptr, - success, - ) + ccall((:SCIPwriteVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint), 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{Libc.FILE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cuint), 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}}, Ptr{Cchar}, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), 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}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{Cchar}}), - scip, - str, - var, - endptr, - ) -end - -function SCIPparseVarsList( - scip, - str, - vars, - nvars, - varssize, - requiredsize, - endptr, - delimiter, - success, -) - ccall( - (:SCIPparseVarsList, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cint}, - Cint, - Ptr{Cint}, - Ptr{Ptr{Cchar}}, - Cchar, - Ptr{Cuint}, - ), - 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}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{Cint}, - Cint, - Ptr{Cint}, - Ptr{Ptr{Cchar}}, - Ptr{Cuint}, - ), - 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}, - Ptr{Cchar}, - Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, - Ptr{Ptr{Ptr{Cdouble}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cint}}, - Ptr{Cint}, - Ptr{Ptr{Cchar}}, - Ptr{Cuint}, - ), - scip, - str, - monomialvars, - monomialexps, - monomialcoefs, - monomialnvars, - nmonomials, - endptr, - success, - ) -end - -function SCIPfreeParseVarsPolynomialData( - scip, - monomialvars, - monomialexps, - monomialcoefs, - monomialnvars, - nmonomials, -) - ccall( - (:SCIPfreeParseVarsPolynomialData, libscip), - Cvoid, - ( - Ptr{SCIP}, - Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, - Ptr{Ptr{Ptr{Cdouble}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cint}}, - Cint, - ), - scip, - monomialvars, - monomialexps, - monomialcoefs, - monomialnvars, - nmonomials, - ) + ccall((:SCIPparseVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{Cchar}}), scip, str, var, endptr) +end + +function SCIPparseVarsList(scip, str, vars, nvars, varssize, requiredsize, endptr, delimiter, success) + ccall((:SCIPparseVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Ptr{Cchar}}, Cchar, Ptr{Cuint}), 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}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) +end + +function SCIPparseVarsLinearsumExact(scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) + ccall((:SCIPparseVarsLinearsumExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), 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}, Ptr{Cchar}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), scip, str, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, endptr, success) +end + +function SCIPfreeParseVarsPolynomialDataExact(scip, monomialvars, monomialcoefs, nmonomials) + ccall((:SCIPfreeParseVarsPolynomialDataExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), scip, monomialvars, monomialcoefs, nmonomials) +end + +function SCIPparseVarsPolynomialExact(scip, str, monomialvars, monomialcoefs, nmonomials, endptr, success) + ccall((:SCIPparseVarsPolynomialExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Cint}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), scip, str, monomialvars, monomialcoefs, 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, - ) + ccall((:SCIPcaptureVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPreleaseVar(scip, var) - ccall( - (:SCIPreleaseVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}), - scip, - var, - ) + ccall((:SCIPreleaseVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}), scip, var) end function SCIPchgVarName(scip, var, name) - ccall( - (:SCIPchgVarName, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cchar}), - scip, - var, - name, - ) + ccall((:SCIPchgVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cchar}), scip, var, name) end function SCIPtransformVar(scip, var, transvar) - ccall( - (:SCIPtransformVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), - scip, - var, - transvar, - ) + ccall((:SCIPtransformVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) end function SCIPtransformVars(scip, nvars, vars, transvars) - ccall( - (:SCIPtransformVars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), - scip, - nvars, - vars, - transvars, - ) + ccall((:SCIPtransformVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) end function SCIPgetTransformedVar(scip, var, transvar) - ccall( - (:SCIPgetTransformedVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), - scip, - var, - transvar, - ) + ccall((:SCIPgetTransformedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) end function SCIPgetTransformedVars(scip, nvars, vars, transvars) - ccall( - (:SCIPgetTransformedVars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), - scip, - nvars, - vars, - transvars, - ) + ccall((:SCIPgetTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) end function SCIPgetNegatedVar(scip, var, negvar) - ccall( - (:SCIPgetNegatedVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), - scip, - var, - negvar, - ) + ccall((:SCIPgetNegatedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, negvar) end function SCIPgetNegatedVars(scip, nvars, vars, negvars) - ccall( - (:SCIPgetNegatedVars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), - scip, - nvars, - vars, - negvars, - ) + ccall((:SCIPgetNegatedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, negvars) end function SCIPgetBinvarRepresentative(scip, var, repvar, negated) - ccall( - (:SCIPgetBinvarRepresentative, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), - scip, - var, - repvar, - negated, - ) + ccall((:SCIPgetBinvarRepresentative, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), 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{Cuint}), - scip, - nvars, - vars, - repvars, - negated, - ) + ccall((:SCIPgetBinvarRepresentatives, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), 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}, - Cuint, - ), - scip, - vars, - scalars, - nvars, - varssize, - constant, - requiredsize, - mergemultiples, - ) + ccall((:SCIPflattenVarAggregationGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPgetProbvarLinearSum(scip, vars, scalars, nvars, varssize, constant, requiredsize) + ccall((:SCIPgetProbvarLinearSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cdouble}, Ptr{Cint}), scip, vars, scalars, nvars, varssize, constant, requiredsize) end function SCIPgetProbvarSum(scip, var, scalar, constant) - ccall( - (:SCIPgetProbvarSum, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), - scip, - var, - scalar, - constant, - ) + ccall((:SCIPgetProbvarSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, scalar, constant) +end + +function SCIPgetProbvarSumExact(scip, var, scalar, constant) + ccall((:SCIPgetProbvarSumExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), scip, var, scalar, constant) end function SCIPgetActiveVars(scip, vars, nvars, varssize, requiredsize) - ccall( - (:SCIPgetActiveVars, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}), - scip, - vars, - nvars, - varssize, - requiredsize, - ) + ccall((:SCIPgetActiveVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}), scip, vars, nvars, varssize, requiredsize) end function SCIPgetVarRedcost(scip, var) - ccall( - (:SCIPgetVarRedcost, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarImplRedcost(scip, var, varfixing) - ccall( - (:SCIPgetVarImplRedcost, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cuint), - scip, - var, - varfixing, - ) + ccall((:SCIPgetVarImplRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cuint), scip, var, varfixing) end function SCIPgetVarFarkasCoef(scip, var) - ccall( - (:SCIPgetVarFarkasCoef, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarLbAtIndex(scip, var, bdchgidx, after) - ccall( - (:SCIPgetVarLbAtIndex, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), - scip, - var, - bdchgidx, - after, - ) + ccall((:SCIPgetVarLbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), scip, var, bdchgidx, after) end function SCIPgetVarUbAtIndex(scip, var, bdchgidx, after) - ccall( - (:SCIPgetVarUbAtIndex, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), - scip, - var, - bdchgidx, - after, - ) + ccall((:SCIPgetVarUbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), 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}, Cuint), - scip, - var, - boundtype, - bdchgidx, - after, - ) + ccall((:SCIPgetVarBdAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cuint), scip, var, boundtype, bdchgidx, after) end function SCIPgetVarWasFixedAtIndex(scip, var, bdchgidx, after) - ccall( - (:SCIPgetVarWasFixedAtIndex, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), - scip, - var, - bdchgidx, - after, - ) + ccall((:SCIPgetVarWasFixedAtIndex, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), scip, var, bdchgidx, after) end function SCIPgetVarSol(scip, var) - ccall( - (:SCIPgetVarSol, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarSol, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarSols(scip, nvars, vars, vals) - ccall( - (:SCIPgetVarSols, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), - scip, - nvars, - vars, - vals, - ) + ccall((:SCIPgetVarSols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nvars, vars, vals) end function SCIPclearRelaxSolVals(scip, relax) - ccall( - (:SCIPclearRelaxSolVals, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}), - scip, - relax, - ) + ccall((:SCIPclearRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}), scip, relax) end function SCIPsetRelaxSolVal(scip, relax, var, val) - ccall( - (:SCIPsetRelaxSolVal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{SCIP_VAR}, Cdouble), - scip, - relax, - var, - val, - ) + ccall((:SCIPsetRelaxSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{SCIP_VAR}, Cdouble), scip, relax, var, val) end function SCIPsetRelaxSolVals(scip, relax, nvars, vars, vals, includeslp) - ccall( - (:SCIPsetRelaxSolVals, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_RELAX}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cuint, - ), - scip, - relax, - nvars, - vars, - vals, - includeslp, - ) + ccall((:SCIPsetRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cuint), scip, relax, nvars, vars, vals, includeslp) end function SCIPsetRelaxSolValsSol(scip, relax, sol, includeslp) - ccall( - (:SCIPsetRelaxSolValsSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{SCIP_SOL}, Cuint), - scip, - relax, - sol, - includeslp, - ) + ccall((:SCIPsetRelaxSolValsSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{SCIP_SOL}, Cuint), scip, relax, sol, includeslp) end function SCIPisRelaxSolValid(scip) @@ -20812,14 +9590,7 @@ function SCIPisRelaxSolValid(scip) end function SCIPmarkRelaxSolValid(scip, relax, includeslp) - ccall( - (:SCIPmarkRelaxSolValid, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cuint), - scip, - relax, - includeslp, - ) + ccall((:SCIPmarkRelaxSolValid, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cuint), scip, relax, includeslp) end function SCIPmarkRelaxSolInvalid(scip) @@ -20827,13 +9598,7 @@ function SCIPmarkRelaxSolInvalid(scip) end function SCIPgetRelaxSolVal(scip, var) - ccall( - (:SCIPgetRelaxSolVal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetRelaxSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetRelaxSolObj(scip) @@ -20841,1211 +9606,283 @@ function SCIPgetRelaxSolObj(scip) end function SCIPisStrongbranchDownFirst(scip, var) - ccall( - (:SCIPisStrongbranchDownFirst, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPisStrongbranchDownFirst, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPstartStrongbranch(scip, enablepropagation) - ccall( - (:SCIPstartStrongbranch, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint), - scip, - enablepropagation, - ) + ccall((:SCIPstartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, enablepropagation) end function SCIPendStrongbranch(scip) ccall((:SCIPendStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPgetVarStrongbranchFrac( - scip, - var, - itlim, - idempotent, - down, - up, - downvalid, - upvalid, - downinf, - upinf, - downconflict, - upconflict, - lperror, -) - ccall( - (:SCIPgetVarStrongbranchFrac, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Cint, - Cuint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - var, - itlim, - idempotent, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Clonglong}, - Ptr{Clonglong}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - 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, - idempotent, - down, - up, - downvalid, - upvalid, - downinf, - upinf, - downconflict, - upconflict, - lperror, -) - ccall( - (:SCIPgetVarStrongbranchInt, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Cint, - Cuint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - var, - itlim, - idempotent, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - vars, - nvars, - itlim, - down, - up, - downvalid, - upvalid, - downinf, - upinf, - downconflict, - upconflict, - lperror, - ) +function SCIPgetVarStrongbranchFrac(scip, var, itlim, idempotent, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarStrongbranchFrac, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, var, itlim, idempotent, 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{Cuint}, Ptr{Cuint}, Ptr{Clonglong}, Ptr{Clonglong}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, 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, idempotent, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) + ccall((:SCIPgetVarStrongbranchInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, var, itlim, idempotent, 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, - Ptr{Cuint}, - 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, - Cuint, - Cuint, - Clonglong, - Cint, - ), - scip, - var, - lpobjval, - primsol, - down, - up, - downvalid, - upvalid, - iter, - itlim, - ) + 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{Cuint}, Ptr{Cuint}, 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, Cuint, Cuint, 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{Cuint}, Ptr{Cuint}), - scip, - foundsol, - cutoff, - ) + ccall((:SCIPtryStrongbranchLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}, Ptr{Cuint}), scip, foundsol, cutoff) end function SCIPgetVarStrongbranchNode(scip, var) - ccall( - (:SCIPgetVarStrongbranchNode, libscip), - Clonglong, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarStrongbranchNode, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarStrongbranchLPAge(scip, var) - ccall( - (:SCIPgetVarStrongbranchLPAge, libscip), - Clonglong, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarStrongbranchLPAge, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarNStrongbranchs(scip, var) - ccall( - (:SCIPgetVarNStrongbranchs, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarNStrongbranchs, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPaddVarLocksType(scip, var, locktype, nlocksdown, nlocksup) - ccall( - (:SCIPaddVarLocksType, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_LOCKTYPE, Cint, Cint), - scip, - var, - locktype, - nlocksdown, - nlocksup, - ) + ccall((:SCIPaddVarLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_LOCKTYPE, Cint, Cint), scip, var, locktype, nlocksdown, nlocksup) end function SCIPaddVarLocks(scip, var, nlocksdown, nlocksup) - ccall( - (:SCIPaddVarLocks, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cint), - scip, - var, - nlocksdown, - nlocksup, - ) + ccall((:SCIPaddVarLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cint), scip, var, nlocksdown, nlocksup) end function SCIPlockVarCons(scip, var, cons, lockdown, lockup) - ccall( - (:SCIPlockVarCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint), - scip, - var, - cons, - lockdown, - lockup, - ) + ccall((:SCIPlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint), 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}, Cuint, Cuint), - scip, - var, - cons, - lockdown, - lockup, - ) + ccall((:SCIPunlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint), scip, var, cons, lockdown, lockup) end function SCIPchgVarObj(scip, var, newobj) - ccall( - (:SCIPchgVarObj, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newobj, - ) + ccall((:SCIPchgVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) end function SCIPaddVarObj(scip, var, addobj) - ccall( - (:SCIPaddVarObj, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - addobj, - ) + ccall((:SCIPaddVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addobj) end function SCIPadjustedVarLb(scip, var, lb) - ccall( - (:SCIPadjustedVarLb, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - lb, - ) + ccall((:SCIPadjustedVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lb) +end + +function SCIPadjustedVarLbExactFloat(scip, var, lb) + ccall((:SCIPadjustedVarLbExactFloat, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lb) end function SCIPadjustedVarUb(scip, var, ub) - ccall( - (:SCIPadjustedVarUb, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - ub, - ) + ccall((:SCIPadjustedVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, ub) +end + +function SCIPadjustedVarUbExactFloat(scip, var, ub) + ccall((:SCIPadjustedVarUbExactFloat, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, ub) end function SCIPchgVarLb(scip, var, newbound) - ccall( - (:SCIPchgVarLb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newbound, - ) + ccall((:SCIPchgVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPchgVarLbExact(scip, var, newbound) + ccall((:SCIPchgVarLbExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) end function SCIPchgVarUb(scip, var, newbound) - ccall( - (:SCIPchgVarUb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newbound, - ) + ccall((:SCIPchgVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) +end + +function SCIPchgVarUbExact(scip, var, newbound) + ccall((:SCIPchgVarUbExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) end function SCIPchgVarLbNode(scip, node, var, newbound) - ccall( - (:SCIPchgVarLbNode, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), - scip, - node, - var, - newbound, - ) + ccall((:SCIPchgVarLbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) end function SCIPchgVarUbNode(scip, node, var, newbound) - ccall( - (:SCIPchgVarUbNode, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), - scip, - node, - var, - newbound, - ) + ccall((:SCIPchgVarUbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) end function SCIPchgVarLbGlobal(scip, var, newbound) - ccall( - (:SCIPchgVarLbGlobal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newbound, - ) + ccall((:SCIPchgVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarUbGlobal(scip, var, newbound) - ccall( - (:SCIPchgVarUbGlobal, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - newbound, - ) + ccall((:SCIPchgVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) end function SCIPchgVarLbLazy(scip, var, lazylb) - ccall( - (:SCIPchgVarLbLazy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - lazylb, - ) + ccall((:SCIPchgVarLbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazylb) end function SCIPchgVarUbLazy(scip, var, lazyub) - ccall( - (:SCIPchgVarUbLazy, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - lazyub, - ) + ccall((:SCIPchgVarUbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazyub) end function SCIPtightenVarLb(scip, var, newbound, force, infeasible, tightened) - ccall( - (:SCIPtightenVarLb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}), - scip, - var, - newbound, - force, - infeasible, - tightened, - ) + ccall((:SCIPtightenVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, force, infeasible, tightened) +end + +function SCIPtightenVarLbExact(scip, var, newbound, infeasible, tightened) + ccall((:SCIPtightenVarLbExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, infeasible, tightened) end function SCIPtightenVarUb(scip, var, newbound, force, infeasible, tightened) - ccall( - (:SCIPtightenVarUb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}), - 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, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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}, - Cuint, - Ptr{SCIP_CONS}, - Cint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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}, - Cuint, - Ptr{SCIP_PROP}, - Cint, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), - 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), - scip, - var, - newbound, - force, - infeasible, - tightened, - ) + ccall((:SCIPtightenVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, force, infeasible, tightened) +end + +function SCIPtightenVarUbExact(scip, var, newbound, infeasible, tightened) + ccall((:SCIPtightenVarUbExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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}, Cuint, Ptr{SCIP_CONS}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, var, fixedval, infercons, inferinfo, infeasible, tightened) +end + +function SCIPinferVarUbConsExact(scip, var, newbound, infercons, inferinfo, infeasible, tightened) + ccall((:SCIPinferVarUbConsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_CONS}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, infercons, inferinfo, infeasible, tightened) +end + +function SCIPinferVarLbConsExact(scip, var, newbound, infercons, inferinfo, infeasible, tightened) + ccall((:SCIPinferVarLbConsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_CONS}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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}, Cuint, Ptr{SCIP_PROP}, Cint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, force, infeasible, tightened) end function SCIPcomputeVarLbGlobal(scip, var) - ccall( - (:SCIPcomputeVarLbGlobal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPcomputeVarLbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPcomputeVarUbGlobal(scip, var) - ccall( - (:SCIPcomputeVarUbGlobal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPcomputeVarUbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPcomputeVarLbLocal(scip, var) - ccall( - (:SCIPcomputeVarLbLocal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPcomputeVarLbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPcomputeVarLbLocalExact(scip, var, result) + ccall((:SCIPcomputeVarLbLocalExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, result) end function SCIPcomputeVarUbLocal(scip, var) - ccall( - (:SCIPcomputeVarUbLocal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPcomputeVarUbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPcomputeVarUbLocalExact(scip, var, result) + ccall((:SCIPcomputeVarUbLocalExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, result) end function SCIPgetVarMultaggrLbGlobal(scip, var) - ccall( - (:SCIPgetVarMultaggrLbGlobal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarMultaggrLbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarMultaggrUbGlobal(scip, var) - ccall( - (:SCIPgetVarMultaggrUbGlobal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarMultaggrUbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarMultaggrLbLocal(scip, var) - ccall( - (:SCIPgetVarMultaggrLbLocal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarMultaggrLbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarMultaggrUbLocal(scip, var) - ccall( - (:SCIPgetVarMultaggrUbLocal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarMultaggrUbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarClosestVlb(scip, var, sol, closestvlb, closestvlbidx) - ccall( - (:SCIPgetVarClosestVlb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), - scip, - var, - sol, - closestvlb, - closestvlbidx, - ) + ccall((:SCIPgetVarClosestVlb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvlb, closestvlbidx) end function SCIPgetVarClosestVub(scip, var, sol, closestvub, closestvubidx) - ccall( - (:SCIPgetVarClosestVub, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), - scip, - var, - sol, - closestvub, - closestvubidx, - ) -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{Cuint}, - 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{Cuint}, - 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}, - Cuint, - Ptr{SCIP_VAR}, - SCIP_BOUNDTYPE, - Cdouble, - Ptr{Cuint}, - 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{Cuint}, - Cint, - Cuint, - Ptr{Cuint}, - 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, - ) + 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{Cuint}, 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{Cuint}, 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}, Cuint, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Cdouble, Ptr{Cuint}, 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{Cuint}, Cint, Cuint, Ptr{Cuint}, Ptr{Cint}), scip, vars, values, nvars, isequation, infeasible, nbdchgs) +end + +function SCIPcalcCliquePartition(scip, vars, nvars, probtoidxmap, probtoidxmapsize, cliquepartition, ncliques) + ccall((:SCIPcalcCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, probtoidxmap, probtoidxmapsize, cliquepartition, ncliques) +end + +function SCIPcalcNegatedCliquePartition(scip, vars, nvars, probtoidxmap, probtoidxmapsize, cliquepartition, ncliques) + ccall((:SCIPcalcNegatedCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, probtoidxmap, probtoidxmapsize, cliquepartition, ncliques) end function SCIPcleanupCliques(scip, infeasible) - ccall( - (:SCIPcleanupCliques, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cuint}), - scip, - infeasible, - ) + ccall((:SCIPcleanupCliques, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, infeasible) end function SCIPgetNCliques(scip) @@ -22060,219 +9897,76 @@ 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), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint, Cuint), - scip, - var1, - value1, - var2, - value2, - regardimplics, - ) +function SCIPhaveVarsCommonClique(scip, var1, value1, var2, value2, regardimplics) + ccall((:SCIPhaveVarsCommonClique, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint, Cuint), scip, var1, value1, var2, value2, regardimplics) end function SCIPwriteCliqueGraph(scip, fname, writenodeweights) - ccall( - (:SCIPwriteCliqueGraph, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Cuint), - scip, - fname, - writenodeweights, - ) + ccall((:SCIPwriteCliqueGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cuint), scip, fname, writenodeweights) end function SCIPremoveVarFromGlobalStructures(scip, var) - ccall( - (:SCIPremoveVarFromGlobalStructures, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPremoveVarFromGlobalStructures, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPchgVarBranchFactor(scip, var, branchfactor) - ccall( - (:SCIPchgVarBranchFactor, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - branchfactor, - ) + ccall((:SCIPchgVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, branchfactor) end function SCIPscaleVarBranchFactor(scip, var, scale) - ccall( - (:SCIPscaleVarBranchFactor, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - scale, - ) + ccall((:SCIPscaleVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, scale) end function SCIPaddVarBranchFactor(scip, var, addfactor) - ccall( - (:SCIPaddVarBranchFactor, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - addfactor, - ) + ccall((:SCIPaddVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addfactor) end function SCIPchgVarBranchPriority(scip, var, branchpriority) - ccall( - (:SCIPchgVarBranchPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), - scip, - var, - branchpriority, - ) + ccall((:SCIPchgVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) end function SCIPupdateVarBranchPriority(scip, var, branchpriority) - ccall( - (:SCIPupdateVarBranchPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), - scip, - var, - branchpriority, - ) + ccall((:SCIPupdateVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) end function SCIPaddVarBranchPriority(scip, var, addpriority) - ccall( - (:SCIPaddVarBranchPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), - scip, - var, - addpriority, - ) + ccall((:SCIPaddVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, addpriority) end function SCIPchgVarBranchDirection(scip, var, branchdirection) - ccall( - (:SCIPchgVarBranchDirection, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - branchdirection, - ) + ccall((:SCIPchgVarBranchDirection, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, branchdirection) end function SCIPchgVarType(scip, var, vartype, infeasible) - ccall( - (:SCIPchgVarType, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_VARTYPE, Ptr{Cuint}), - scip, - var, - vartype, - infeasible, - ) + ccall((:SCIPchgVarType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_VARTYPE, Ptr{Cuint}), scip, var, vartype, infeasible) +end + +function SCIPchgVarImplType(scip, var, impltype, infeasible) + ccall((:SCIPchgVarImplType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_IMPLINTTYPE, Ptr{Cuint}), scip, var, impltype, infeasible) end function SCIPfixVar(scip, var, fixedval, infeasible, fixed) - ccall( - (:SCIPfixVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{Cuint}, Ptr{Cuint}), - 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{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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{Cuint}, - Ptr{Cuint}, - ), - scip, - var, - naggvars, - aggvars, - scalars, - constant, - infeasible, - aggregated, - ) + ccall((:SCIPfixVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{Cuint}, Ptr{Cuint}), scip, var, fixedval, infeasible, fixed) +end + +function SCIPfixVarExact(scip, var, fixedval, infeasible, fixed) + ccall((:SCIPfixVarExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) +end + +function SCIPaggregateVarsExact(scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) + ccall((:SCIPaggregateVarsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, Ptr{Cuint}), scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) +end + +function SCIPmultiaggregateVarExact(scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) + ccall((:SCIPmultiaggregateVarExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) end function SCIPdoNotAggr(scip) @@ -22284,59 +9978,31 @@ function SCIPdoNotMultaggr(scip) end function SCIPdoNotAggrVar(scip, var) - ccall( - (:SCIPdoNotAggrVar, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPdoNotAggrVar, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPdoNotMultaggrVar(scip, var) - ccall( - (:SCIPdoNotMultaggrVar, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPdoNotMultaggrVar, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end -function SCIPallowDualReds(scip) - ccall((:SCIPallowDualReds, libscip), Cuint, (Ptr{SCIP},), scip) +function SCIPisVarAggrCoefAcceptable(scip, var, scalar) + ccall((:SCIPisVarAggrCoefAcceptable, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, scalar) end function SCIPallowStrongDualReds(scip) ccall((:SCIPallowStrongDualReds, libscip), Cuint, (Ptr{SCIP},), scip) end -function SCIPallowObjProp(scip) - ccall((:SCIPallowObjProp, libscip), Cuint, (Ptr{SCIP},), scip) -end - function SCIPallowWeakDualReds(scip) ccall((:SCIPallowWeakDualReds, libscip), Cuint, (Ptr{SCIP},), scip) end function SCIPmarkDoNotAggrVar(scip, var) - ccall( - (:SCIPmarkDoNotAggrVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPmarkDoNotAggrVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPmarkDoNotMultaggrVar(scip, var) - ccall( - (:SCIPmarkDoNotMultaggrVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPmarkDoNotMultaggrVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPenableVarHistory(scip) @@ -22348,1690 +10014,451 @@ function SCIPdisableVarHistory(scip) end function SCIPupdateVarPseudocost(scip, var, solvaldelta, objdelta, weight) - ccall( - (:SCIPupdateVarPseudocost, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), - scip, - var, - solvaldelta, - objdelta, - weight, - ) + ccall((:SCIPupdateVarPseudocost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, var, solvaldelta, objdelta, weight) +end + +function SCIPupdateVarAncPseudocost(scip, var, solvaldelta, objdelta, weight) + ccall((:SCIPupdateVarAncPseudocost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, var, solvaldelta, objdelta, weight) end function SCIPgetVarPseudocostVal(scip, var, solvaldelta) - ccall( - (:SCIPgetVarPseudocostVal, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - solvaldelta, - ) + ccall((:SCIPgetVarPseudocostVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) +end + +function SCIPgetVarAncPseudocostVal(scip, var, solvaldelta) + ccall((:SCIPgetVarAncPseudocostVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) end function SCIPgetVarPseudocostValCurrentRun(scip, var, solvaldelta) - ccall( - (:SCIPgetVarPseudocostValCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - solvaldelta, - ) + ccall((:SCIPgetVarPseudocostValCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) end function SCIPgetVarPseudocost(scip, var, dir) - ccall( - (:SCIPgetVarPseudocost, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarPseudocost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarPseudocostCurrentRun(scip, var, dir) - ccall( - (:SCIPgetVarPseudocostCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarPseudocostCount(scip, var, dir) - ccall( - (:SCIPgetVarPseudocostCount, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarPseudocostCountCurrentRun(scip, var, dir) - ccall( - (:SCIPgetVarPseudocostCountCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) +end + +function SCIPgetVarAncPseudocostCountCurrentRun(scip, var, dir) + ccall((:SCIPgetVarAncPseudocostCountCurrentRun, 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, Cuint), - scip, - var, - dir, - onlycurrentrun, - ) -end - -function SCIPcalculatePscostConfidenceBound( - scip, - var, - dir, - onlycurrentrun, - clevel, -) - ccall( - (:SCIPcalculatePscostConfidenceBound, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cuint, SCIP_CONFIDENCELEVEL), - scip, - var, - dir, - onlycurrentrun, - clevel, - ) -end - -function SCIPsignificantVarPscostDifference( - scip, - varx, - fracx, - vary, - fracy, - dir, - clevel, - onesided, -) - ccall( - (:SCIPsignificantVarPscostDifference, libscip), - Cuint, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Cdouble, - Ptr{SCIP_VAR}, - Cdouble, - SCIP_BRANCHDIR, - SCIP_CONFIDENCELEVEL, - Cuint, - ), - scip, - varx, - fracx, - vary, - fracy, - dir, - clevel, - onesided, - ) -end - -function SCIPpscostThresholdProbabilityTest( - scip, - var, - frac, - threshold, - dir, - clevel, -) - ccall( - (:SCIPpscostThresholdProbabilityTest, libscip), - Cuint, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - SCIP_BRANCHDIR, - SCIP_CONFIDENCELEVEL, - ), - scip, - var, - frac, - threshold, - dir, - clevel, - ) + ccall((:SCIPgetVarPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cuint), scip, var, dir, onlycurrentrun) end -function SCIPisVarPscostRelerrorReliable(scip, var, threshold, clevel) - ccall( - (:SCIPisVarPscostRelerrorReliable, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, SCIP_CONFIDENCELEVEL), - scip, - var, - threshold, - clevel, - ) +function SCIPcalculatePscostConfidenceBound(scip, var, dir, onlycurrentrun, clevel) + ccall((:SCIPcalculatePscostConfidenceBound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cuint, SCIP_CONFIDENCELEVEL), scip, var, dir, onlycurrentrun, clevel) end -function SCIPgetVarPseudocostScore(scip, var, solval) - ccall( - (:SCIPgetVarPseudocostScore, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - solval, - ) +function SCIPsignificantVarPscostDifference(scip, varx, fracx, vary, fracy, dir, clevel, onesided) + ccall((:SCIPsignificantVarPscostDifference, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_VAR}, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL, Cuint), scip, varx, fracx, vary, fracy, dir, clevel, onesided) end -function SCIPgetVarPseudocostScoreCurrentRun(scip, var, solval) - ccall( - (:SCIPgetVarPseudocostScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - solval, - ) +function SCIPpscostThresholdProbabilityTest(scip, var, frac, threshold, dir, clevel) + ccall((:SCIPpscostThresholdProbabilityTest, libscip), Cuint, (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), Cuint, (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 SCIPgetVarDPseudocostScore(scip, var, solval, discountfac) + ccall((:SCIPgetVarDPseudocostScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, solval, discountfac) +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, - ) + ccall((:SCIPgetVarVSIDS, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarVSIDSCurrentRun(scip, var, dir) - ccall( - (:SCIPgetVarVSIDSCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarVSIDSCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarConflictScore(scip, var) - ccall( - (:SCIPgetVarConflictScore, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarConflictScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarConflictScoreCurrentRun(scip, var) - ccall( - (:SCIPgetVarConflictScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarConflictlengthScore(scip, var) - ccall( - (:SCIPgetVarConflictlengthScore, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarConflictlengthScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarConflictlengthScoreCurrentRun(scip, var) - ccall( - (:SCIPgetVarConflictlengthScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarAvgConflictlength(scip, var, dir) - ccall( - (:SCIPgetVarAvgConflictlength, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarAvgConflictlength, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgConflictlengthCurrentRun(scip, var, dir) - ccall( - (:SCIPgetVarAvgConflictlengthCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarAvgConflictlengthCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgInferences(scip, var, dir) - ccall( - (:SCIPgetVarAvgInferences, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarAvgInferences, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgInferencesCurrentRun(scip, var, dir) - ccall( - (:SCIPgetVarAvgInferencesCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgInferenceScore(scip, var) - ccall( - (:SCIPgetVarAvgInferenceScore, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarAvgInferenceScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarAvgInferenceScoreCurrentRun(scip, var) - ccall( - (:SCIPgetVarAvgInferenceScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) -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, - ) + 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, - ) + ccall((:SCIPgetVarAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgCutoffsCurrentRun(scip, var, dir) - ccall( - (:SCIPgetVarAvgCutoffsCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - scip, - var, - dir, - ) + ccall((:SCIPgetVarAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) end function SCIPgetVarAvgCutoffScore(scip, var) - ccall( - (:SCIPgetVarAvgCutoffScore, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarAvgCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarAvgCutoffScoreCurrentRun(scip, var) - ccall( - (:SCIPgetVarAvgCutoffScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - var, - ) + ccall((:SCIPgetVarAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) end function SCIPgetVarAvgInferenceCutoffScore(scip, var, cutoffweight) - ccall( - (:SCIPgetVarAvgInferenceCutoffScore, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - cutoffweight, - ) + ccall((:SCIPgetVarAvgInferenceCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) end function SCIPgetVarAvgInferenceCutoffScoreCurrentRun(scip, var, cutoffweight) - ccall( - (:SCIPgetVarAvgInferenceCutoffScoreCurrentRun, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), - scip, - var, - cutoffweight, - ) + ccall((:SCIPgetVarAvgInferenceCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) +end + +function SCIPgetVarAvgGMIScore(scip, var) + ccall((:SCIPgetVarAvgGMIScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPincVarGMISumScore(scip, var, gmieff) + ccall((:SCIPincVarGMISumScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, gmieff) +end + +function SCIPgetVarLastGMIScore(scip, var) + ccall((:SCIPgetVarLastGMIScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) +end + +function SCIPsetVarLastGMIScore(scip, var, gmieff) + ccall((:SCIPsetVarLastGMIScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, gmieff) end function SCIPprintVar(scip, var, file) - ccall( - (:SCIPprintVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Libc.FILE}), - scip, - var, - file, - ) -end - -function SCIPselectVarPseudoStrongBranching( - scip, - pseudocands, - skipdown, - skipup, - npseudocands, - npriopseudocands, - bestpseudocand, - bestdown, - bestup, - bestscore, - bestdownvalid, - bestupvalid, - provedbound, - result, -) - ccall( - (:SCIPselectVarPseudoStrongBranching, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cuint}, - Ptr{Cuint}, - Cint, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cdouble}, - Ptr{SCIP_RESULT}, - ), - scip, - pseudocands, - skipdown, - skipup, - npseudocands, - npriopseudocands, - bestpseudocand, - bestdown, - bestup, - bestscore, - bestdownvalid, - bestupvalid, - provedbound, - result, - ) + ccall((:SCIPprintVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Libc.FILE}), scip, var, file) +end + +function SCIPchgVarObjExact(scip, var, newobj) + ccall((:SCIPchgVarObjExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newobj) +end + +function SCIPchgVarUbGlobalExact(scip, var, newbound) + ccall((:SCIPchgVarUbGlobalExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) +end + +function SCIPchgVarLbGlobalExact(scip, var, newbound) + ccall((:SCIPchgVarLbGlobalExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) +end + +function SCIPwriteVarsLinearsumExact(scip, file, vars, vals, nvars, type) + ccall((:SCIPwriteVarsLinearsumExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint, Cuint), scip, file, vars, vals, nvars, type) +end + +function SCIPgetProbvarLinearSumExact(scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) + ccall((:SCIPgetProbvarLinearSumExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Cint}, Cint, Ptr{SCIP_RATIONAL}, Ptr{Cint}, Cuint), scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) +end + +function SCIPselectVarPseudoStrongBranching(scip, pseudocands, skipdown, skipup, npseudocands, npriopseudocands, bestpseudocand, bestdown, bestup, bestscore, bestdownvalid, bestupvalid, provedbound, result) + ccall((:SCIPselectVarPseudoStrongBranching, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}, Ptr{Cuint}, Cint, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Ptr{SCIP_RESULT}), scip, pseudocands, skipdown, skipup, npseudocands, npriopseudocands, bestpseudocand, bestdown, bestup, bestscore, bestdownvalid, bestupvalid, provedbound, result) end function SCIPincludeBranchruleAllfullstrong(scip) - ccall( - (:SCIPincludeBranchruleAllfullstrong, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleAllfullstrong, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleCloud(scip) - ccall( - (:SCIPincludeBranchruleCloud, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleCloud, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleDistribution(scip) - ccall( - (:SCIPincludeBranchruleDistribution, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPvarCalcDistributionParameters( - scip, - varlb, - varub, - vartype, - mean, - variance, -) - ccall( - (:SCIPvarCalcDistributionParameters, libscip), - Cvoid, - (Ptr{SCIP}, Cdouble, Cdouble, SCIP_VARTYPE, Ptr{Cdouble}, Ptr{Cdouble}), - scip, - varlb, - varub, - vartype, - mean, - variance, - ) + ccall((:SCIPincludeBranchruleDistribution, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPvarCalcDistributionParameters(scip, varlb, varub, vartype, impltype, mean, variance) + ccall((:SCIPvarCalcDistributionParameters, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, SCIP_VARTYPE, SCIP_IMPLINTTYPE, Ptr{Cdouble}, Ptr{Cdouble}), scip, varlb, varub, vartype, impltype, mean, variance) end function SCIPcalcCumulativeDistribution(scip, mean, variance, value) - ccall( - (:SCIPcalcCumulativeDistribution, libscip), - Cdouble, - (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), - scip, - mean, - variance, - value, - ) -end - -function SCIProwCalcProbability( - scip, - row, - mu, - sigma2, - rowinfinitiesdown, - rowinfinitiesup, -) - ccall( - (:SCIProwCalcProbability, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Cint, Cint), - scip, - row, - mu, - sigma2, - rowinfinitiesdown, - rowinfinitiesup, - ) -end - -function SCIPupdateDistributionScore( - scip, - currentprob, - newprobup, - newprobdown, - upscore, - downscore, - scoreparam, -) - ccall( - (:SCIPupdateDistributionScore, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Cdouble, - Cdouble, - Cdouble, - Ptr{Cdouble}, - Ptr{Cdouble}, - Cchar, - ), - scip, - currentprob, - newprobup, - newprobdown, - upscore, - downscore, - scoreparam, - ) + ccall((:SCIPcalcCumulativeDistribution, libscip), Cdouble, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, mean, variance, value) +end + +function SCIProwCalcProbability(scip, row, mu, sigma2, rowinfinitiesdown, rowinfinitiesup) + ccall((:SCIProwCalcProbability, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Cint, Cint), scip, row, mu, sigma2, rowinfinitiesdown, rowinfinitiesup) +end + +function SCIPupdateDistributionScore(scip, currentprob, newprobup, newprobdown, upscore, downscore, scoreparam) + ccall((:SCIPupdateDistributionScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Cchar), scip, currentprob, newprobup, newprobdown, upscore, downscore, scoreparam) end function SCIPincludeBranchruleFullstrong(scip) - ccall( - (:SCIPincludeBranchruleFullstrong, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPselectVarStrongBranching( - scip, - lpcands, - lpcandssol, - lpcandsfrac, - skipdown, - skipup, - nlpcands, - npriolpcands, - ncomplete, - start, - maxproprounds, - probingbounds, - forcestrongbranch, - bestcand, - bestdown, - bestup, - bestscore, - bestdownvalid, - bestupvalid, - provedbound, - result, -) - ccall( - (:SCIPselectVarStrongBranching, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Cint, - Cint, - Cint, - Ptr{Cint}, - Cint, - Cuint, - Cuint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cdouble}, - Ptr{SCIP_RESULT}, - ), - scip, - lpcands, - lpcandssol, - lpcandsfrac, - skipdown, - skipup, - nlpcands, - npriolpcands, - ncomplete, - start, - maxproprounds, - probingbounds, - forcestrongbranch, - bestcand, - bestdown, - bestup, - bestscore, - bestdownvalid, - bestupvalid, - provedbound, - result, - ) + ccall((:SCIPincludeBranchruleFullstrong, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPselectVarStrongBranching(scip, lpcands, lpcandssol, lpcandsfrac, skipdown, skipup, nlpcands, npriolpcands, ncomplete, start, maxproprounds, probingbounds, forcestrongbranch, bestcand, bestdown, bestup, bestscore, bestdownvalid, bestupvalid, provedbound, result) + ccall((:SCIPselectVarStrongBranching, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Cint, Cint, Cint, Ptr{Cint}, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Ptr{SCIP_RESULT}), scip, lpcands, lpcandssol, lpcandsfrac, skipdown, skipup, nlpcands, npriolpcands, ncomplete, start, maxproprounds, probingbounds, forcestrongbranch, bestcand, bestdown, bestup, bestscore, bestdownvalid, bestupvalid, provedbound, result) +end + +function SCIPincludeBranchruleGomory(scip) + ccall((:SCIPincludeBranchruleGomory, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleInference(scip) - ccall( - (:SCIPincludeBranchruleInference, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleInference, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleLeastinf(scip) - ccall( - (:SCIPincludeBranchruleLeastinf, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleLeastinf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleLookahead(scip) - ccall( - (:SCIPincludeBranchruleLookahead, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleLookahead, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleMostinf(scip) - ccall( - (:SCIPincludeBranchruleMostinf, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleMostinf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleMultAggr(scip) - ccall( - (:SCIPincludeBranchruleMultAggr, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleMultAggr, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleNodereopt(scip) - ccall( - (:SCIPincludeBranchruleNodereopt, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleNodereopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchrulePscost(scip) - ccall( - (:SCIPincludeBranchrulePscost, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPselectBranchVarPscost( - scip, - branchcands, - branchcandssol, - branchcandsscore, - nbranchcands, - var, - brpoint, -) - ccall( - (:SCIPselectBranchVarPscost, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - ), - scip, - branchcands, - branchcandssol, - branchcandsscore, - nbranchcands, - var, - brpoint, - ) + ccall((:SCIPincludeBranchrulePscost, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPselectBranchVarPscost(scip, branchcands, branchcandssol, branchcandsscore, nbranchcands, var, brpoint) + ccall((:SCIPselectBranchVarPscost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, branchcands, branchcandssol, branchcandsscore, nbranchcands, var, brpoint) end function SCIPincludeBranchruleRandom(scip) - ccall( - (:SCIPincludeBranchruleRandom, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeBranchruleRandom, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeBranchruleRelpscost(scip) - ccall( - (:SCIPincludeBranchruleRelpscost, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPexecRelpscostBranching( - scip, - branchcands, - branchcandssol, - branchcandsfrac, - nbranchcands, - executebranching, - result, -) - ccall( - (:SCIPexecRelpscostBranching, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Cint, - Cuint, - Ptr{SCIP_RESULT}, - ), - scip, - branchcands, - branchcandssol, - branchcandsfrac, - nbranchcands, - executebranching, - result, - ) + ccall((:SCIPincludeBranchruleRelpscost, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPexecRelpscostBranching(scip, branchcands, branchcandssol, branchcandsfrac, nbranchcands, executebranching, result) + ccall((:SCIPexecRelpscostBranching, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Cint, Cuint, Ptr{SCIP_RESULT}), scip, branchcands, branchcandssol, branchcandsfrac, nbranchcands, executebranching, result) end function SCIPincludeBranchruleVanillafullstrong(scip) - ccall( - (:SCIPincludeBranchruleVanillafullstrong, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPgetVanillafullstrongData( - scip, - cands, - candscores, - ncands, - npriocands, - bestcand, -) - ccall( - (:SCIPgetVanillafullstrongData, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - cands, - candscores, - ncands, - npriocands, - bestcand, - ) + ccall((:SCIPincludeBranchruleVanillafullstrong, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetVanillafullstrongData(scip, cands, candscores, ncands, npriocands, bestcand) + ccall((:SCIPgetVanillafullstrongData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, cands, candscores, ncands, npriocands, bestcand) end function SCIPincludeComprLargestrepr(scip) - ccall( - (:SCIPincludeComprLargestrepr, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeComprLargestrepr, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end function SCIPincludeComprWeakcompr(scip) - ccall( - (:SCIPincludeComprWeakcompr, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeComprWeakcompr, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end 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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - resvar, - nvars, - vars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) +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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - ), - scip, - cons, - name, - resvar, - nvars, - vars, - ) + ccall((:SCIPcreateConsBasicAnd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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, - ) + 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, - ) + 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, - ) + ccall((:SCIPgetResultantAnd, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end function SCIPisAndConsSorted(scip, cons) - ccall( - (:SCIPisAndConsSorted, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) + ccall((:SCIPisAndConsSorted, libscip), Cuint, (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}, Cuint), - scip, - cons, - flag, - ) -end - -function SCIPchgAndConsRemovableFlagWhenUpgr(scip, cons, flag) - ccall( - (:SCIPchgAndConsRemovableFlagWhenUpgr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), - scip, - cons, - flag, - ) + ccall((:SCIPsortAndCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end 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, - Cuint, - ), - scip, - sol, - conshdlr, - result, - type, - checkint, - ) + 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, Cuint), scip, sol, conshdlr, result, type, checkint) end function SCIPincludeConshdlrBenderslp(scip) - ccall( - (:SCIPincludeConshdlrBenderslp, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeConshdlrBenderslp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{SCIP_BOUNDTYPE}, - Ptr{Cdouble}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{SCIP_BOUNDTYPE}, - Ptr{Cdouble}, - ), - scip, - cons, - name, - nvars, - vars, - boundtypes, - bounds, - ) -end - -function SCIPcreateConsBounddisjunctionRedundant( - scip, - cons, - name, - nvars, - vars, - boundtypes, - bounds, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, -) - ccall( - (:SCIPcreateConsBounddisjunctionRedundant, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{SCIP_BOUNDTYPE}, - Ptr{Cdouble}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nvars, - vars, - boundtypes, - bounds, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) -end - -function SCIPcreateConsBasicBounddisjunctionRedundant( - scip, - cons, - name, - nvars, - vars, - boundtypes, - bounds, -) - ccall( - (:SCIPcreateConsBasicBounddisjunctionRedundant, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{SCIP_BOUNDTYPE}, - Ptr{Cdouble}, - ), - scip, - cons, - name, - nvars, - vars, - boundtypes, - bounds, - ) + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}), scip, cons, name, nvars, vars, boundtypes, bounds) +end + +function SCIPcreateConsBounddisjunctionRedundant(scip, cons, name, nvars, vars, boundtypes, bounds, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsBounddisjunctionRedundant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, boundtypes, bounds, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicBounddisjunctionRedundant(scip, cons, name, nvars, vars, boundtypes, bounds) + ccall((:SCIPcreateConsBasicBounddisjunctionRedundant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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, - ) + 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, - ) + 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, - ) + 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, - ) + ccall((:SCIPgetBoundsBounddisjunction, libscip), Ptr{Cdouble}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - ), - scip, - cons, - name, - nvars, - vars, - cardval, - indvars, - weights, - ) + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + ccall((:SCIPgetWeightsCardinality, libscip), Ptr{Cdouble}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nconss, - conss, - enforce, - check, - _local, - modifiable, - dynamic, - ) + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_CONS}}, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_CONS}}), - scip, - cons, - name, - nconss, - conss, - ) + ccall((:SCIPcreateConsBasicConjunction, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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, - ) + ccall((:SCIPaddConsElemConjunction, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons, addcons) end function SCIPincludeConshdlrCountsols(scip) - ccall( - (:SCIPincludeConshdlrCountsols, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - 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, - ) + 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, - ) + 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, - ) + 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) @@ -24039,53 +10466,19 @@ function SCIPcount(scip) end function SCIPgetNCountedSols(scip, valid) - ccall( - (:SCIPgetNCountedSols, libscip), - Clonglong, - (Ptr{SCIP}, Ptr{Cuint}), - scip, - valid, - ) + ccall((:SCIPgetNCountedSols, libscip), Clonglong, (Ptr{SCIP}, Ptr{Cuint}), scip, valid) end function SCIPgetNCountedSolsstr(scip, buffer, buffersize, requiredsize) - ccall( - (:SCIPgetNCountedSolsstr, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}), - scip, - buffer, - buffersize, - requiredsize, - ) + ccall((:SCIPgetNCountedSolsstr, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}), scip, buffer, buffersize, requiredsize) end function SCIPgetNCountedFeasSubtrees(scip) - ccall( - (:SCIPgetNCountedFeasSubtrees, libscip), - Clonglong, - (Ptr{SCIP},), - 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, - ) + 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) @@ -24093,1055 +10486,171 @@ function SCIPsetParamsCountsols(scip) end 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cint}, - Ptr{Cint}, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cint}, - Ptr{Cint}, - Cint, - ), - scip, - cons, - name, - nvars, - vars, - durations, - demands, - capacity, - ) + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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{Cuint}, - Ptr{SCIP_CONS}, - Cuint, - ), - 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{Cuint}, - Ptr{Cuint}, - Ptr{SCIP_CONS}, - Ptr{Cuint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cuint}, - ), - 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{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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{Cuint}, - Ptr{SCIP_RESULT}, - ), - scip, - nvars, - vars, - durations, - demands, - capacity, - hmin, - hmax, - infervar, - inferinfo, - boundtype, - bdchgidx, - relaxedbd, - explanation, - result, - ) + 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{Cuint}, Ptr{SCIP_CONS}, Cuint), 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, irrelevants, nfixedvars, nchgsides, cutoff) + ccall((:SCIPpresolveCumulativeCondition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Cint, Ptr{Cuint}, Ptr{Cuint}, Ptr{SCIP_CONS}, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}), scip, nvars, vars, durations, hmin, hmax, downlocks, uplocks, cons, irrelevants, 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, 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, - ) + 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{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - 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, - ) + 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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, - ) + 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, - ) + ccall((:SCIPcomputeHmax, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PROFILE}, Cint), scip, profile, capacity) end 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Ptr{SCIP_CONS}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Ptr{SCIP_CONS}, - ), - scip, - cons, - name, - nconss, - conss, - relaxcons, - ) + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONS}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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, - ) + ccall((:SCIPaddConsElemDisjunction, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons, addcons) +end + +function SCIPincludeConshdlrFixedvar(scip) + ccall((:SCIPincludeConshdlrFixedvar, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end 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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cdouble, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cdouble, - ), - scip, - cons, - name, - binvar, - nvars, - vars, - vals, - rhs, - ) -end - -function SCIPcreateConsIndicatorGeneric( - scip, - cons, - name, - binvar, - nvars, - vars, - vals, - rhs, - activeone, - lessthanineq, - initial, - separate, - enforce, - check, - propagate, - _local, - dynamic, - removable, - stickingatnode, -) - ccall( - (:SCIPcreateConsIndicatorGeneric, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cdouble, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - binvar, - nvars, - vars, - vals, - rhs, - activeone, - lessthanineq, - initial, - separate, - enforce, - check, - propagate, - _local, - dynamic, - removable, - stickingatnode, - ) -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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{SCIP_CONS}, - Ptr{SCIP_VAR}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - binvar, - lincons, - slackvar, - initial, - separate, - enforce, - check, - propagate, - _local, - dynamic, - removable, - stickingatnode, - ) -end - -function SCIPcreateConsIndicatorGenericLinCons( - scip, - cons, - name, - binvar, - lincons, - slackvar, - activeone, - initial, - separate, - enforce, - check, - propagate, - _local, - dynamic, - removable, - stickingatnode, -) - ccall( - (:SCIPcreateConsIndicatorGenericLinCons, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{SCIP_CONS}, - Ptr{SCIP_VAR}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - binvar, - lincons, - slackvar, - activeone, - 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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{SCIP_CONS}, - Ptr{SCIP_VAR}, - ), - scip, - cons, - name, - binvar, - lincons, - slackvar, - ) + 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble), scip, cons, name, binvar, nvars, vars, vals, rhs) +end + +function SCIPcreateConsIndicatorGeneric(scip, cons, name, binvar, nvars, vars, vals, rhs, activeone, lessthanineq, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsIndicatorGeneric, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, nvars, vars, vals, rhs, activeone, lessthanineq, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, lincons, slackvar, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsIndicatorGenericLinCons(scip, cons, name, binvar, lincons, slackvar, activeone, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsIndicatorGenericLinCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, lincons, slackvar, activeone, 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, name, binvar, lincons, slackvar) +end + +function SCIPcreateConsIndicatorGenericLinConsPure(scip, cons, name, binvar, lincons, activeone, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsIndicatorGenericLinConsPure, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, lincons, activeone, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsIndicatorLinConsPure(scip, cons, name, binvar, lincons, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsIndicatorLinConsPure, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, lincons, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) 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, - ) + 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, - ) + 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, - ) + 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, - ) + ccall((:SCIPsetBinaryVarIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, binvar) end function SCIPgetActiveOnIndicator(cons) @@ -25149,496 +10658,119 @@ function SCIPgetActiveOnIndicator(cons) end function SCIPgetBinaryVarIndicator(cons) - ccall( - (:SCIPgetBinaryVarIndicator, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_CONS},), - cons, - ) + ccall((:SCIPgetBinaryVarIndicator, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_CONS},), cons) end function SCIPgetBinaryVarIndicatorGeneric(cons) - ccall( - (:SCIPgetBinaryVarIndicatorGeneric, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_CONS},), - cons, - ) + ccall((:SCIPgetBinaryVarIndicatorGeneric, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_CONS},), cons) end function SCIPgetSlackVarIndicator(cons) - ccall( - (:SCIPgetSlackVarIndicator, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_CONS},), - 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, - ) + ccall((:SCIPsetSlackVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, ub) end function SCIPisViolatedIndicator(scip, cons, sol) - ccall( - (:SCIPisViolatedIndicator, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}), - scip, - cons, - sol, - ) + ccall((:SCIPisViolatedIndicator, libscip), Cuint, (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{Cuint}), - scip, - cons, - sol, - changed, - ) + ccall((:SCIPmakeIndicatorFeasible, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cuint}), 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{Cuint}), - scip, - conshdlr, - sol, - changed, - ) + ccall((:SCIPmakeIndicatorsFeasible, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_SOL}, Ptr{Cuint}), 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, - ) + 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, - ) + ccall((:SCIPaddRowIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_ROW}), scip, conshdlr, row) end function SCIPincludeConshdlrIntegral(scip) - ccall( - (:SCIPincludeConshdlrIntegral, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeConshdlrIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Clonglong}, - Clonglong, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Clonglong}, - Clonglong, - ), - scip, - cons, - name, - nvars, - vars, - weights, - capacity, - ) + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Clonglong}, Clonglong, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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{Cuint}, - ), - 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}, - Cuint, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cint}, - ), - scip, - cons, - sepa, - nknapvars, - knapvars, - knapvals, - valscale, - rhs, - sol, - cutoff, - ncuts, - ) -end - -function SCIPcleanupConssKnapsack(scip, onlychecked, infeasible) - ccall( - (:SCIPcleanupConssKnapsack, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint, Ptr{Cuint}), - scip, - onlychecked, - infeasible, - ) + ccall((:SCIPgetRowKnapsack, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPcreateRowKnapsack(scip, cons) + ccall((:SCIPcreateRowKnapsack, libscip), SCIP_RETCODE, (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{Cuint}), 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}, Cuint, Ptr{Cuint}, 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{Cuint}, Ptr{Cint}), scip, cons, sepa, nknapvars, knapvars, knapvals, valscale, rhs, sol, cutoff, ncuts) +end + +function SCIPcleanupConssKnapsack(scip, onlychecked, infeasible, ndelconss) + ccall((:SCIPcleanupConssKnapsack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}), scip, onlychecked, infeasible, ndelconss) end function SCIPincludeConshdlrLinear(scip) - ccall( - (:SCIPincludeConshdlrLinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) + ccall((:SCIPincludeConshdlrLinear, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end const SCIP_LinConsUpgrade = Cvoid @@ -25646,33043 +10778,12730 @@ const SCIP_LinConsUpgrade = Cvoid const SCIP_LINCONSUPGRADE = SCIP_LinConsUpgrade function SCIPincludeLinconsUpgrade(scip, linconsupgd, priority, conshdlrname) - ccall( - (:SCIPincludeLinconsUpgrade, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cvoid}, Cint, Ptr{Cchar}), - 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - 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}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Ptr{SCIP_HASHMAP}, - Ptr{SCIP_HASHMAP}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Ptr{Cuint}, - ), - scip, - cons, - sourcescip, - name, - nvars, - sourcevars, - sourcecoefs, - lhs, - rhs, - varmap, - consmap, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - _global, - valid, - ) + ccall((:SCIPincludeLinconsUpgrade, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}, Cint, Ptr{Cchar}), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + ccall((:SCIPgetRowLinear, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPcreateRowLinear(scip, cons) + ccall((:SCIPcreateRowLinear, libscip), SCIP_RETCODE, (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, - ) + 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 - -function SCIPcleanupConssLinear(scip, onlychecked, infeasible) - ccall( - (:SCIPcleanupConssLinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint, Ptr{Cuint}), - scip, - onlychecked, - infeasible, - ) + ccall((:SCIPclassifyConstraintTypesLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_LINCONSSTATS}), scip, linconsstats) end -function SCIPincludeConshdlrLinking(scip) - ccall( - (:SCIPincludeConshdlrLinking, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPcreateConsLinking( - scip, - cons, - name, - linkvar, - binvars, - vals, - nbinvars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, -) - ccall( - (:SCIPcreateConsLinking, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - linkvar, - binvars, - vals, - nbinvars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) -end - -function SCIPcreateConsBasicLinking( - scip, - cons, - name, - linkvar, - binvars, - vals, - nbinvars, -) - ccall( - (:SCIPcreateConsBasicLinking, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cint, - ), - scip, - cons, - name, - linkvar, - binvars, - vals, - nbinvars, - ) +function SCIPcleanupConssLinear(scip, onlychecked, infeasible, ndelconss) + ccall((:SCIPcleanupConssLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}), scip, onlychecked, infeasible, ndelconss) end -function SCIPexistsConsLinking(scip, linkvar) - ccall( - (:SCIPexistsConsLinking, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - linkvar, - ) +function SCIPincludeConshdlrExactLinear(scip) + ccall((:SCIPincludeConshdlrExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPgetConsLinking(scip, linkvar) - ccall( - (:SCIPgetConsLinking, libscip), - Ptr{SCIP_CONS}, - (Ptr{SCIP}, Ptr{SCIP_VAR}), - scip, - linkvar, - ) +function SCIPcreateConsExactLinear(scip, cons, name, nvars, vars, vals, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, vals, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) end -function SCIPgetLinkvarLinking(scip, cons) - ccall( - (:SCIPgetLinkvarLinking, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPcreateConsBasicExactLinear(scip, cons, name, nvars, vars, vals, lhs, rhs) + ccall((:SCIPcreateConsBasicExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), scip, cons, name, nvars, vars, vals, lhs, rhs) 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, - ) +function SCIPcopyConsExactLinear(scip, cons, sourcescip, name, nvars, sourcevars, sourcecoefs, lhs, rhs, varmap, consmap, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) + ccall((:SCIPcopyConsExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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 SCIPgetNBinvarsLinking(scip, cons) - ccall( - (:SCIPgetNBinvarsLinking, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPaddCoefExactLinear(scip, cons, var, val) + ccall((:SCIPaddCoefExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, cons, var, val) end -function SCIPgetValsLinking(scip, cons) - ccall( - (:SCIPgetValsLinking, libscip), - Ptr{Cdouble}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPchgCoefExactLinear(scip, cons, var, val) + ccall((:SCIPchgCoefExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, cons, var, val) end -function SCIPgetBinvarsDataLinking(cons, binvars, vals, nbinvars) - ccall( - (:SCIPgetBinvarsDataLinking, libscip), - SCIP_RETCODE, - (Ptr{SCIP_CONS}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}), - cons, - binvars, - vals, - nbinvars, - ) +function SCIPdelCoefExactLinear(scip, cons, var) + ccall((:SCIPdelCoefExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, var) end -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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nvars, - vars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) +function SCIPgetLhsExactLinear(scip, cons) + ccall((:SCIPgetLhsExactLinear, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPcreateConsBasicLogicor(scip, cons, name, nvars, vars) - ccall( - (:SCIPcreateConsBasicLogicor, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}), - scip, - cons, - name, - nvars, - vars, - ) +function SCIPgetRhsExactLinear(scip, cons) + ccall((:SCIPgetRhsExactLinear, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPaddCoefLogicor(scip, cons, var) - ccall( - (:SCIPaddCoefLogicor, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), - scip, - cons, - var, - ) +function SCIPchgLhsExactLinear(scip, cons, lhs) + ccall((:SCIPchgLhsExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), scip, cons, lhs) end -function SCIPgetNVarsLogicor(scip, cons) - ccall( - (:SCIPgetNVarsLogicor, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPchgRhsExactLinear(scip, cons, rhs) + ccall((:SCIPchgRhsExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), scip, cons, rhs) end -function SCIPgetVarsLogicor(scip, cons) - ccall( - (:SCIPgetVarsLogicor, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPgetNVarsExactLinear(scip, cons) + ccall((:SCIPgetNVarsExactLinear, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPgetDualsolLogicor(scip, cons) - ccall( - (:SCIPgetDualsolLogicor, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPgetVarsExactLinear(scip, cons) + ccall((:SCIPgetVarsExactLinear, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPgetDualfarkasLogicor(scip, cons) - ccall( - (:SCIPgetDualfarkasLogicor, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPgetValsRealExactLinear(scip, cons) + ccall((:SCIPgetValsRealExactLinear, libscip), Ptr{SCIP_INTERVAL}, (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 - -function SCIPcleanupConssLogicor( - scip, - onlychecked, - naddconss, - ndelconss, - nchgcoefs, -) - ccall( - (:SCIPcleanupConssLogicor, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), - scip, - onlychecked, - naddconss, - ndelconss, - nchgcoefs, - ) +function SCIPgetValsExactLinear(scip, cons) + ccall((:SCIPgetValsExactLinear, libscip), Ptr{Ptr{SCIP_RATIONAL}}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -struct SCIP_ConsNonlinear_Auxexpr - coefs::NTuple{3,Cdouble} - cst::Cdouble - auxvar::Ptr{SCIP_VAR} - underestimate::Cuint - overestimate::Cuint +function SCIPgetActivityExactLinear(scip, cons, sol, ret) + ccall((:SCIPgetActivityExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, cons, sol, ret) end -const SCIP_CONSNONLINEAR_AUXEXPR = SCIP_ConsNonlinear_Auxexpr +function SCIPgetFeasibilityExactLinear(scip, cons, sol, ret) + ccall((:SCIPgetFeasibilityExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, cons, sol, ret) +end -struct __JL_Ctag_674 - data::NTuple{8,UInt8} +function SCIPgetFpDualsolExactLinear(scip, cons, ret) + ccall((:SCIPgetFpDualsolExactLinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), scip, cons, ret) end -function Base.getproperty(x::Ptr{__JL_Ctag_674}, f::Symbol) - f === :exprs && return Ptr{Ptr{Ptr{SCIP_CONSNONLINEAR_AUXEXPR}}}(x + 0) - f === :var && return Ptr{Ptr{SCIP_VAR}}(x + 0) - return getfield(x, f) +function SCIPgetFpDualfarkasExactLinear(scip, cons, ret) + ccall((:SCIPgetFpDualfarkasExactLinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), scip, cons, ret) end -function Base.getproperty(x::__JL_Ctag_674, f::Symbol) - r = Ref{__JL_Ctag_674}(x) - ptr = Base.unsafe_convert(Ptr{__JL_Ctag_674}, r) - fptr = getproperty(ptr, f) - GC.@preserve r unsafe_load(fptr) +function SCIPgetRowExactLinear(scip, cons) + ccall((:SCIPgetRowExactLinear, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function Base.setproperty!(x::Ptr{__JL_Ctag_674}, f::Symbol, v) - unsafe_store!(getproperty(x, f), v) +function SCIPgetRowExactExactLinear(scip, cons) + ccall((:SCIPgetRowExactExactLinear, libscip), Ptr{SCIP_ROWEXACT}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -struct SCIP_ConsNonlinear_BilinTerm - data::NTuple{48,UInt8} +function SCIPcertifyConsOrigExactLinear(scip, conshdlr, cons) + ccall((:SCIPcertifyConsOrigExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONS}), scip, conshdlr, cons) end -function Base.getproperty(x::Ptr{SCIP_ConsNonlinear_BilinTerm}, f::Symbol) - f === :x && return Ptr{Ptr{SCIP_VAR}}(x + 0) - f === :y && return Ptr{Ptr{SCIP_VAR}}(x + 8) - f === :aux && return Ptr{__JL_Ctag_674}(x + 16) - f === :nauxexprs && return Ptr{Cint}(x + 24) - f === :auxexprssize && return Ptr{Cint}(x + 28) - f === :nlockspos && return Ptr{Cint}(x + 32) - f === :nlocksneg && return Ptr{Cint}(x + 36) - f === :existing && return Ptr{Cuint}(x + 40) - return getfield(x, f) +function colLink(col, blkmem, set, eventqueue, lp) + ccall((:colLink, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), col, blkmem, set, eventqueue, lp) end -function Base.getproperty(x::SCIP_ConsNonlinear_BilinTerm, f::Symbol) - r = Ref{SCIP_ConsNonlinear_BilinTerm}(x) - ptr = Base.unsafe_convert(Ptr{SCIP_ConsNonlinear_BilinTerm}, r) - fptr = getproperty(ptr, f) - GC.@preserve r unsafe_load(fptr) +function colUnlink(col, blkmem, set, eventqueue, lp) + ccall((:colUnlink, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), col, blkmem, set, eventqueue, lp) end -function Base.setproperty!(x::Ptr{SCIP_ConsNonlinear_BilinTerm}, f::Symbol, v) - unsafe_store!(getproperty(x, f), v) +function rowLink(row, blkmem, set, eventqueue, lp) + ccall((:rowLink, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), row, blkmem, set, eventqueue, lp) end -const SCIP_CONSNONLINEAR_BILINTERM = SCIP_ConsNonlinear_BilinTerm +function rowUnlink(row, set, lp) + ccall((:rowUnlink, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), row, set, lp) +end -function SCIPincludeConshdlrNonlinear(scip) - ccall( - (:SCIPincludeConshdlrNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPincludeConsUpgradeNonlinear( - scip, - nlconsupgd, - priority, - active, - conshdlrname, -) - ccall( - (:SCIPincludeConsUpgradeNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cvoid}, Cint, Cuint, Ptr{Cchar}), - scip, - nlconsupgd, - priority, - active, - conshdlrname, - ) -end - -function SCIPcreateConsNonlinear( - scip, - cons, - name, - expr, - lhs, - rhs, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, -) - ccall( - (:SCIPcreateConsNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_EXPR}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - expr, - lhs, - rhs, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - ) +function SCIPcolCreate(col, blkmem, set, stat, var, len, rows, vals, removable) + ccall((:SCIPcolCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_ROW}}, Ptr{Cdouble}, Cuint), col, blkmem, set, stat, var, len, rows, vals, removable) end -function SCIPcreateConsBasicNonlinear(scip, cons, name, expr, lhs, rhs) - ccall( - (:SCIPcreateConsBasicNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_EXPR}, - Cdouble, - Cdouble, - ), - scip, - cons, - name, - expr, - lhs, - rhs, - ) -end - -function SCIPcreateConsQuadraticNonlinear( - scip, - cons, - name, - nlinvars, - linvars, - lincoefs, - nquadterms, - quadvars1, - quadvars2, - quadcoefs, - lhs, - rhs, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, -) - ccall( - (:SCIPcreateConsQuadraticNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nlinvars, - linvars, - lincoefs, - nquadterms, - quadvars1, - quadvars2, - quadcoefs, - lhs, - rhs, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - ) -end - -function SCIPcreateConsBasicQuadraticNonlinear( - scip, - cons, - name, - nlinvars, - linvars, - lincoefs, - nquadterms, - quadvars1, - quadvars2, - quadcoefs, - lhs, - rhs, -) - ccall( - (:SCIPcreateConsBasicQuadraticNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - 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 SCIPcreateConsBasicSignpowerNonlinear( - scip, - cons, - name, - x, - z, - exponent, - xoffset, - zcoef, - lhs, - rhs, -) - ccall( - (:SCIPcreateConsBasicSignpowerNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - ), - scip, - cons, - name, - x, - z, - exponent, - xoffset, - zcoef, - lhs, - rhs, - ) +function SCIPcolFree(col, blkmem, set, eventqueue, lp) + ccall((:SCIPcolFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), col, blkmem, set, eventqueue, lp) end -function SCIPgetCurBoundsTagNonlinear(conshdlr) - ccall( - (:SCIPgetCurBoundsTagNonlinear, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPcolPrint(col, messagehdlr, file) + ccall((:SCIPcolPrint, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), col, messagehdlr, file) end -function SCIPgetLastBoundRelaxTagNonlinear(conshdlr) - ccall( - (:SCIPgetLastBoundRelaxTagNonlinear, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPcolAddCoef(col, blkmem, set, eventqueue, lp, row, val) + ccall((:SCIPcolAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_ROW}, Cdouble), col, blkmem, set, eventqueue, lp, row, val) end -function SCIPincrementCurBoundsTagNonlinear(conshdlr, boundrelax) - ccall( - (:SCIPincrementCurBoundsTagNonlinear, libscip), - Cvoid, - (Ptr{SCIP_CONSHDLR}, Cuint), - conshdlr, - boundrelax, - ) +function SCIPcolDelCoef(col, blkmem, set, eventqueue, lp, row) + ccall((:SCIPcolDelCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_ROW}), col, blkmem, set, eventqueue, lp, row) end -function SCIPgetVarExprHashmapNonlinear(conshdlr) - ccall( - (:SCIPgetVarExprHashmapNonlinear, libscip), - Ptr{SCIP_HASHMAP}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) -end - -function SCIPprocessRowprepNonlinear( - scip, - nlhdlr, - cons, - expr, - rowprep, - overestimate, - auxvar, - auxvalue, - allowweakcuts, - branchscoresuccess, - inenforcement, - sol, - result, -) - ccall( - (:SCIPprocessRowprepNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLHDLR}, - Ptr{SCIP_CONS}, - Ptr{SCIP_EXPR}, - Ptr{SCIP_ROWPREP}, - Cuint, - Ptr{SCIP_VAR}, - Cdouble, - Cuint, - Cuint, - Cuint, - Ptr{SCIP_SOL}, - Ptr{SCIP_RESULT}, - ), - scip, - nlhdlr, - cons, - expr, - rowprep, - overestimate, - auxvar, - auxvalue, - allowweakcuts, - branchscoresuccess, - inenforcement, - sol, - result, - ) +function SCIPcolChgCoef(col, blkmem, set, eventqueue, lp, row, val) + ccall((:SCIPcolChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_ROW}, Cdouble), col, blkmem, set, eventqueue, lp, row, val) end -function SCIPcollectBilinTermsNonlinear(scip, conshdlr, conss, nconss) - ccall( - (:SCIPcollectBilinTermsNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Ptr{SCIP_CONS}}, Cint), - scip, - conshdlr, - conss, - nconss, - ) +function SCIPcolIncCoef(col, blkmem, set, eventqueue, lp, row, incval) + ccall((:SCIPcolIncCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_ROW}, Cdouble), col, blkmem, set, eventqueue, lp, row, incval) end -function SCIPgetNBilinTermsNonlinear(conshdlr) - ccall( - (:SCIPgetNBilinTermsNonlinear, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPcolChgObj(col, set, lp, newobj) + ccall((:SCIPcolChgObj, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), col, set, lp, newobj) end -function SCIPgetBilinTermsNonlinear(conshdlr) - ccall( - (:SCIPgetBilinTermsNonlinear, libscip), - Ptr{SCIP_CONSNONLINEAR_BILINTERM}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPcolChgLb(col, set, lp, newlb) + ccall((:SCIPcolChgLb, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), col, set, lp, newlb) end -function SCIPgetBilinTermIdxNonlinear(conshdlr, x, y) - ccall( - (:SCIPgetBilinTermIdxNonlinear, libscip), - Cint, - (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), - conshdlr, - x, - y, - ) +function SCIPcolChgUb(col, set, lp, newub) + ccall((:SCIPcolChgUb, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), col, set, lp, newub) end -function SCIPgetBilinTermNonlinear(conshdlr, x, y) - ccall( - (:SCIPgetBilinTermNonlinear, libscip), - Ptr{SCIP_CONSNONLINEAR_BILINTERM}, - (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), - conshdlr, - x, - y, - ) +function SCIPcolCalcRedcost(col, dualsol) + ccall((:SCIPcolCalcRedcost, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{Cdouble}), col, dualsol) end -function SCIPevalBilinAuxExprNonlinear(scip, x, y, auxexpr, sol) - ccall( - (:SCIPevalBilinAuxExprNonlinear, libscip), - Cdouble, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Ptr{SCIP_VAR}, - Ptr{SCIP_CONSNONLINEAR_AUXEXPR}, - Ptr{SCIP_SOL}, - ), - scip, - x, - y, - auxexpr, - sol, - ) -end - -function SCIPinsertBilinearTermExistingNonlinear( - scip, - conshdlr, - x, - y, - auxvar, - nlockspos, - nlocksneg, -) - ccall( - (:SCIPinsertBilinearTermExistingNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_CONSHDLR}, - Ptr{SCIP_VAR}, - Ptr{SCIP_VAR}, - Ptr{SCIP_VAR}, - Cint, - Cint, - ), - scip, - conshdlr, - x, - y, - auxvar, - nlockspos, - nlocksneg, - ) -end - -function SCIPinsertBilinearTermImplicitNonlinear( - scip, - conshdlr, - x, - y, - auxvar, - coefx, - coefy, - coefaux, - cst, - overestimate, -) - ccall( - (:SCIPinsertBilinearTermImplicitNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_CONSHDLR}, - Ptr{SCIP_VAR}, - Ptr{SCIP_VAR}, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cuint, - ), - scip, - conshdlr, - x, - y, - auxvar, - coefx, - coefy, - coefaux, - cst, - overestimate, - ) -end - -function SCIPcomputeFacetVertexPolyhedralNonlinear( - scip, - conshdlr, - overestimate, - _function, - fundata, - xstar, - box, - nallvars, - targetvalue, - success, - facetcoefs, - facetconstant, -) - ccall( - (:SCIPcomputeFacetVertexPolyhedralNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_CONSHDLR}, - Cuint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Cint, - Cdouble, - Ptr{Cuint}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - scip, - conshdlr, - overestimate, - _function, - fundata, - xstar, - box, - nallvars, - targetvalue, - success, - facetcoefs, - facetconstant, - ) +function SCIPcolGetRedcost(col, stat, lp) + ccall((:SCIPcolGetRedcost, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, stat, lp) end -function SCIPgetExprNonlinear(cons) - ccall( - (:SCIPgetExprNonlinear, libscip), - Ptr{SCIP_EXPR}, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPcolGetFeasibility(col, set, stat, lp) + ccall((:SCIPcolGetFeasibility, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, set, stat, lp) end -function SCIPgetLhsNonlinear(cons) - ccall((:SCIPgetLhsNonlinear, libscip), Cdouble, (Ptr{SCIP_CONS},), cons) +function SCIPcolCalcFarkasCoef(col, dualfarkas) + ccall((:SCIPcolCalcFarkasCoef, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{Cdouble}), col, dualfarkas) end -function SCIPgetRhsNonlinear(cons) - ccall((:SCIPgetRhsNonlinear, libscip), Cdouble, (Ptr{SCIP_CONS},), cons) +function SCIPcolGetFarkasCoef(col, stat, lp) + ccall((:SCIPcolGetFarkasCoef, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, stat, lp) end -function SCIPgetNlRowNonlinear(scip, cons, nlrow) - ccall( - (:SCIPgetNlRowNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_NLROW}}), - scip, - cons, - nlrow, - ) +function SCIPcolGetFarkasValue(col, stat, lp) + ccall((:SCIPcolGetFarkasValue, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, stat, lp) end -function SCIPgetCurvatureNonlinear(cons) - ccall( - (:SCIPgetCurvatureNonlinear, libscip), - SCIP_EXPRCURV, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPlpStartStrongbranch(lp) + ccall((:SCIPlpStartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_LP},), lp) end -function SCIPcheckQuadraticNonlinear(scip, cons, isquadratic) - ccall( - (:SCIPcheckQuadraticNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), - scip, - cons, - isquadratic, - ) +function SCIPlpEndStrongbranch(lp) + ccall((:SCIPlpEndStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_LP},), lp) end -function SCIPchgLhsNonlinear(scip, cons, lhs) - ccall( - (:SCIPchgLhsNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), - scip, - cons, - lhs, - ) +function SCIPcolSetStrongbranchData(col, set, stat, lp, lpobjval, primsol, sbdown, sbup, sbdownvalid, sbupvalid, iter, itlim) + ccall((:SCIPcolSetStrongbranchData, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}, Cdouble, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Clonglong, Cint), col, set, stat, lp, lpobjval, primsol, sbdown, sbup, sbdownvalid, sbupvalid, iter, itlim) end -function SCIPchgRhsNonlinear(scip, cons, rhs) - ccall( - (:SCIPchgRhsNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), - scip, - cons, - rhs, - ) +function SCIPcolInvalidateStrongbranchData(col, set, stat, lp) + ccall((:SCIPcolInvalidateStrongbranchData, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, set, stat, lp) end -function SCIPchgExprNonlinear(scip, cons, expr) - ccall( - (:SCIPchgExprNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}), - scip, - cons, - expr, - ) +function SCIPcolGetStrongbranch(col, integral, set, stat, prob, lp, itlim, updatecol, updatestat, down, up, downvalid, upvalid, lperror) + ccall((:SCIPcolGetStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Cuint, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Cint, Cuint, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), col, integral, set, stat, prob, lp, itlim, updatecol, updatestat, down, up, downvalid, upvalid, lperror) 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, - ) +function SCIPcolGetStrongbranches(cols, ncols, integral, set, stat, prob, lp, itlim, down, up, downvalid, upvalid, lperror) + ccall((:SCIPcolGetStrongbranches, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COL}}, Cint, Cuint, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), cols, ncols, integral, set, stat, prob, lp, itlim, down, up, downvalid, upvalid, lperror) end -function SCIPaddExprNonlinear(scip, cons, expr, coef) - ccall( - (:SCIPaddExprNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}, Cdouble), - scip, - cons, - expr, - coef, - ) +function SCIPcolGetStrongbranchLast(col, down, up, downvalid, upvalid, solval, lpobjval) + ccall((:SCIPcolGetStrongbranchLast, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Ptr{Cdouble}), col, down, up, downvalid, upvalid, solval, lpobjval) end -function SCIPgetAbsViolationNonlinear(scip, cons, sol, viol) - ccall( - (:SCIPgetAbsViolationNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), - scip, - cons, - sol, - viol, - ) +function SCIPcolGetStrongbranchLPAge(col, stat) + ccall((:SCIPcolGetStrongbranchLPAge, libscip), Clonglong, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}), col, stat) end -function SCIPgetRelViolationNonlinear(scip, cons, sol, viol) - ccall( - (:SCIPgetRelViolationNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), - scip, - cons, - sol, - viol, - ) +function SCIPcolMarkNotRemovableLocal(col, stat) + ccall((:SCIPcolMarkNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}), col, stat) end -function SCIPgetLinvarMayDecreaseNonlinear(scip, cons, var, coef) - ccall( - (:SCIPgetLinvarMayDecreaseNonlinear, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), - scip, - cons, - var, - coef, - ) +function SCIProwCreate(row, blkmem, set, stat, name, len, cols, vals, lhs, rhs, origintype, origin, _local, modifiable, removable) + ccall((:SCIProwCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROW}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, SCIP_ROWORIGINTYPE, Ptr{Cvoid}, Cuint, Cuint, Cuint), row, blkmem, set, stat, name, len, cols, vals, lhs, rhs, origintype, origin, _local, modifiable, removable) end -function SCIPgetLinvarMayIncreaseNonlinear(scip, cons, var, coef) - ccall( - (:SCIPgetLinvarMayIncreaseNonlinear, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), - scip, - cons, - var, - coef, - ) +function SCIProwFree(row, blkmem, set, lp) + ccall((:SCIProwFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROW}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), row, blkmem, set, lp) end -function SCIPgetExprNLocksPosNonlinear(expr) - ccall( - (:SCIPgetExprNLocksPosNonlinear, libscip), - Cint, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIProwPrint(row, messagehdlr, file) + ccall((:SCIProwPrint, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), row, messagehdlr, file) end -function SCIPgetExprNLocksNegNonlinear(expr) - ccall( - (:SCIPgetExprNLocksNegNonlinear, libscip), - Cint, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIProwEnsureSize(row, blkmem, set, num) + ccall((:SCIProwEnsureSize, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), row, blkmem, set, num) end -function SCIPgetExprAuxVarNonlinear(expr) - ccall( - (:SCIPgetExprAuxVarNonlinear, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIProwCapture(row) + ccall((:SCIProwCapture, libscip), Cvoid, (Ptr{SCIP_ROW},), row) end -function SCIPgetExprNEnfosNonlinear(expr) - ccall((:SCIPgetExprNEnfosNonlinear, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +function SCIProwRelease(row, blkmem, set, lp) + ccall((:SCIProwRelease, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROW}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), row, blkmem, set, lp) end -function SCIPgetExprEnfoDataNonlinear( - expr, - idx, - nlhdlr, - nlhdlrexprdata, - nlhdlrparticipation, - sepabelowusesactivity, - sepaaboveusesactivity, - auxvalue, -) - ccall( - (:SCIPgetExprEnfoDataNonlinear, libscip), - Cvoid, - ( - Ptr{SCIP_EXPR}, - Cint, - Ptr{Ptr{SCIP_NLHDLR}}, - Ptr{Ptr{SCIP_NLHDLREXPRDATA}}, - Ptr{SCIP_NLHDLR_METHOD}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cdouble}, - ), - expr, - idx, - nlhdlr, - nlhdlrexprdata, - nlhdlrparticipation, - sepabelowusesactivity, - sepaaboveusesactivity, - auxvalue, - ) +function SCIProwDelaySort(row) + ccall((:SCIProwDelaySort, libscip), Cvoid, (Ptr{SCIP_ROW},), row) end -function SCIPsetExprEnfoAuxValueNonlinear(expr, idx, auxvalue) - ccall( - (:SCIPsetExprEnfoAuxValueNonlinear, libscip), - Cvoid, - (Ptr{SCIP_EXPR}, Cint, Cdouble), - expr, - idx, - auxvalue, - ) +function SCIProwForceSort(row, set) + ccall((:SCIProwForceSort, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) end -function SCIPgetExprNPropUsesActivityNonlinear(expr) - ccall( - (:SCIPgetExprNPropUsesActivityNonlinear, libscip), - Cuint, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIProwAddCoef(row, blkmem, set, eventqueue, lp, col, val) + ccall((:SCIProwAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_COL}, Cdouble), row, blkmem, set, eventqueue, lp, col, val) end -function SCIPgetExprNSepaUsesActivityNonlinear(expr) - ccall( - (:SCIPgetExprNSepaUsesActivityNonlinear, libscip), - Cuint, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIProwDelCoef(row, blkmem, set, eventqueue, lp, col) + ccall((:SCIProwDelCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_COL}), row, blkmem, set, eventqueue, lp, col) end -function SCIPgetExprNAuxvarUsesNonlinear(expr) - ccall( - (:SCIPgetExprNAuxvarUsesNonlinear, libscip), - Cuint, - (Ptr{SCIP_EXPR},), - expr, - ) -end - -function SCIPregisterExprUsageNonlinear( - scip, - expr, - useauxvar, - useactivityforprop, - useactivityforsepabelow, - useactivityforsepaabove, -) - ccall( - (:SCIPregisterExprUsageNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cuint, Cuint, Cuint, Cuint), - scip, - expr, - useauxvar, - useactivityforprop, - useactivityforsepabelow, - useactivityforsepaabove, - ) -end - -function SCIPgetExprAbsOrigViolationNonlinear( - scip, - expr, - sol, - soltag, - viol, - violunder, - violover, -) - ccall( - (:SCIPgetExprAbsOrigViolationNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Ptr{SCIP_SOL}, - Clonglong, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - expr, - sol, - soltag, - viol, - violunder, - violover, - ) -end - -function SCIPgetExprAbsAuxViolationNonlinear( - scip, - expr, - auxvalue, - sol, - viol, - violunder, - violover, -) - ccall( - (:SCIPgetExprAbsAuxViolationNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Cdouble, - Ptr{SCIP_SOL}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - expr, - auxvalue, - sol, - viol, - violunder, - violover, - ) -end - -function SCIPgetExprRelAuxViolationNonlinear( - scip, - expr, - auxvalue, - sol, - viol, - violunder, - violover, -) - ccall( - (:SCIPgetExprRelAuxViolationNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - Cdouble, - Ptr{SCIP_SOL}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - scip, - expr, - auxvalue, - sol, - viol, - violunder, - violover, - ) +function SCIProwChgCoef(row, blkmem, set, eventqueue, lp, col, val) + ccall((:SCIProwChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_COL}, Cdouble), row, blkmem, set, eventqueue, lp, col, val) end -function SCIPgetExprBoundsNonlinear(scip, expr) - ccall( - (:SCIPgetExprBoundsNonlinear, libscip), - SCIP_INTERVAL, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) -end - -function SCIPtightenExprIntervalNonlinear( - scip, - expr, - newbounds, - cutoff, - ntightenings, -) - ccall( - (:SCIPtightenExprIntervalNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_INTERVAL, Ptr{Cuint}, Ptr{Cint}), - scip, - expr, - newbounds, - cutoff, - ntightenings, - ) +function SCIProwIncCoef(row, blkmem, set, eventqueue, lp, col, incval) + ccall((:SCIProwIncCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_COL}, Cdouble), row, blkmem, set, eventqueue, lp, col, incval) end -function SCIPmarkExprPropagateNonlinear(scip, expr) - ccall( - (:SCIPmarkExprPropagateNonlinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) +function SCIProwChgConstant(row, blkmem, set, stat, eventqueue, lp, constant) + ccall((:SCIProwChgConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Cdouble), row, blkmem, set, stat, eventqueue, lp, constant) end -function SCIPaddExprViolScoreNonlinear(scip, expr, violscore) - ccall( - (:SCIPaddExprViolScoreNonlinear, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cdouble), - scip, - expr, - violscore, - ) -end - -function SCIPaddExprsViolScoreNonlinear( - scip, - exprs, - nexprs, - violscore, - sol, - success, -) - ccall( - (:SCIPaddExprsViolScoreNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Cint, - Cdouble, - Ptr{SCIP_SOL}, - Ptr{Cuint}, - ), - scip, - exprs, - nexprs, - violscore, - sol, - success, - ) +function SCIProwAddConstant(row, blkmem, set, stat, eventqueue, lp, addval) + ccall((:SCIProwAddConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Cdouble), row, blkmem, set, stat, eventqueue, lp, addval) end -function SCIPgetExprViolScoreNonlinear(expr) - ccall( - (:SCIPgetExprViolScoreNonlinear, libscip), - Cdouble, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIProwChgLhs(row, blkmem, set, eventqueue, lp, lhs) + ccall((:SCIProwChgLhs, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Cdouble), row, blkmem, set, eventqueue, lp, lhs) end -function SCIPgetExprPartialDiffNonlinear(scip, expr, var) - ccall( - (:SCIPgetExprPartialDiffNonlinear, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_VAR}), - scip, - expr, - var, - ) +function SCIProwChgRhs(row, blkmem, set, eventqueue, lp, rhs) + ccall((:SCIProwChgRhs, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Cdouble), row, blkmem, set, eventqueue, lp, rhs) end -function SCIPgetExprPartialDiffGradientDirNonlinear(scip, expr, var) - ccall( - (:SCIPgetExprPartialDiffGradientDirNonlinear, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_VAR}), - scip, - expr, - var, - ) +function SCIProwChgLocal(row, _local) + ccall((:SCIProwChgLocal, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Cuint), row, _local) end -function SCIPevalExprQuadraticAuxNonlinear(scip, expr, sol) - ccall( - (:SCIPevalExprQuadraticAuxNonlinear, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}), - scip, - expr, - sol, - ) -end - -function SCIPincludeNlhdlrNonlinear( - scip, - nlhdlr, - name, - desc, - detectpriority, - enfopriority, - detect, - evalaux, - nlhdlrdata, -) - ccall( - (:SCIPincludeNlhdlrNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_NLHDLR}}, - Ptr{Cchar}, - Ptr{Cchar}, - Cint, - Cint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_NLHDLRDATA}, - ), - scip, - nlhdlr, - name, - desc, - detectpriority, - enfopriority, - detect, - evalaux, - nlhdlrdata, - ) +function SCIProwCalcIntegralScalar(row, set, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) + ccall((:SCIProwCalcIntegralScalar, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Cdouble, Cdouble, Clonglong, Cdouble, Cuint, Ptr{Cdouble}, Ptr{Cuint}), row, set, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) end -function SCIPfindNlhdlrNonlinear(conshdlr, name) - ccall( - (:SCIPfindNlhdlrNonlinear, libscip), - Ptr{SCIP_NLHDLR}, - (Ptr{SCIP_CONSHDLR}, Ptr{Cchar}), - conshdlr, - name, - ) +function SCIProwMakeIntegral(row, blkmem, set, eventqueue, stat, lp, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) + ccall((:SCIProwMakeIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}, Cdouble, Cdouble, Clonglong, Cdouble, Cuint, Ptr{Cuint}), row, blkmem, set, eventqueue, stat, lp, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) end -function SCIPgetNlhdlrExprDataNonlinear(nlhdlr, expr) - ccall( - (:SCIPgetNlhdlrExprDataNonlinear, libscip), - Ptr{SCIP_NLHDLREXPRDATA}, - (Ptr{SCIP_NLHDLR}, Ptr{SCIP_EXPR}), - nlhdlr, - expr, - ) +function SCIProwRecalcNorms(row, set) + ccall((:SCIProwRecalcNorms, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) end -function SCIPincludeConshdlrOr(scip) - ccall((:SCIPincludeConshdlrOr, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwRecalcLPActivity(row, stat) + ccall((:SCIProwRecalcLPActivity, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), row, stat) 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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - resvar, - nvars, - vars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) +function SCIProwGetLPActivity(row, set, stat, lp) + ccall((:SCIProwGetLPActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), row, set, stat, lp) end -function SCIPcreateConsBasicOr(scip, cons, name, resvar, nvars, vars) - ccall( - (:SCIPcreateConsBasicOr, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - ), - scip, - cons, - name, - resvar, - nvars, - vars, - ) +function SCIProwGetLPFeasibility(row, set, stat, lp) + ccall((:SCIProwGetLPFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), row, set, stat, lp) end -function SCIPgetNVarsOr(scip, cons) - ccall( - (:SCIPgetNVarsOr, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIProwGetRelaxFeasibility(row, set, stat) + ccall((:SCIProwGetRelaxFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) end -function SCIPgetVarsOr(scip, cons) - ccall( - (:SCIPgetVarsOr, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIProwGetNLPFeasibility(row, set, stat) + ccall((:SCIProwGetNLPFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) end -function SCIPgetResultantOr(scip, cons) - ccall( - (:SCIPgetResultantOr, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIProwRecalcPseudoActivity(row, stat) + ccall((:SCIProwRecalcPseudoActivity, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), row, stat) end -function SCIPincludeConshdlrOrbisack(scip) - ccall( - (:SCIPincludeConshdlrOrbisack, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -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, - Cuint, - Ptr{Cuint}, - ), - scip, - sol, - vars1, - vars2, - nrows, - printreason, - feasible, - ) -end - -function SCIPcreateConsOrbisack( - scip, - cons, - name, - vars1, - vars2, - nrows, - ispporbisack, - isparttype, - ismodelcons, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, -) - ccall( - (:SCIPcreateConsOrbisack, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - vars1, - vars2, - nrows, - ispporbisack, - isparttype, - ismodelcons, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) -end - -function SCIPcreateConsBasicOrbisack( - scip, - cons, - name, - vars1, - vars2, - nrows, - ispporbisack, - isparttype, - ismodelcons, -) - ccall( - (:SCIPcreateConsBasicOrbisack, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - vars1, - vars2, - nrows, - ispporbisack, - isparttype, - ismodelcons, - ) +function SCIProwGetPseudoActivity(row, set, stat) + ccall((:SCIProwGetPseudoActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) end -const SYM_SPEC = UInt32 +function SCIProwGetPseudoFeasibility(row, set, stat) + ccall((:SCIProwGetPseudoFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) +end -@enum SYM_Rhssense::UInt32 begin - SYM_SENSE_UNKOWN = 0 - SYM_SENSE_INEQUALITY = 1 - SYM_SENSE_EQUATION = 2 - SYM_SENSE_XOR = 3 - SYM_SENSE_AND = 4 - SYM_SENSE_OR = 5 - SYM_SENSE_BOUNDIS_TYPE_1 = 6 - SYM_SENSE_BOUNDIS_TYPE_2 = 7 +function SCIProwGetSolActivity(row, set, stat, sol) + ccall((:SCIProwGetSolActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), row, set, stat, sol) end -const SYM_RHSSENSE = SYM_Rhssense +function SCIProwGetSolFeasibility(row, set, stat, sol) + ccall((:SCIProwGetSolFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), row, set, stat, sol) +end -const SYM_HANDLETYPE = UInt32 +function SCIProwGetMinActivity(row, set, stat) + ccall((:SCIProwGetMinActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) +end -const SYM_Vartype = Cvoid +function SCIProwGetMaxActivity(row, set, stat) + ccall((:SCIProwGetMaxActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) +end -const SYM_VARTYPE = SYM_Vartype +function SCIProwIsRedundant(row, set, stat) + ccall((:SCIProwIsRedundant, libscip), Cuint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) +end -const SYM_Optype = Cvoid +function SCIProwGetMaxval(row, set) + ccall((:SCIProwGetMaxval, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) +end -const SYM_OPTYPE = SYM_Optype +function SCIProwGetMinval(row, set) + ccall((:SCIProwGetMinval, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) +end -const SYM_Consttype = Cvoid +function SCIProwGetMaxidx(row, set) + ccall((:SCIProwGetMaxidx, libscip), Cint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) +end -const SYM_CONSTTYPE = SYM_Consttype +function SCIProwGetMinidx(row, set) + ccall((:SCIProwGetMinidx, libscip), Cint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) +end -const SYM_Rhstype = Cvoid +function SCIProwGetNumIntCols(row, set) + ccall((:SCIProwGetNumIntCols, libscip), Cint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) +end -const SYM_RHSTYPE = SYM_Rhstype +function SCIProwGetNumImpliedIntCols(row, set) + ccall((:SCIProwGetNumImpliedIntCols, libscip), Cint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) +end -const SYM_Matrixdata = Cvoid +function SCIProwGetLPSolCutoffDistance(row, set, stat, sol, lp) + ccall((:SCIProwGetLPSolCutoffDistance, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Ptr{SCIP_LP}), row, set, stat, sol, lp) +end -const SYM_MATRIXDATA = SYM_Matrixdata +function SCIProwGetLPEfficacy(row, set, stat, lp) + ccall((:SCIProwGetLPEfficacy, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), row, set, stat, lp) +end -const SYM_Exprdata = Cvoid +function SCIProwIsLPEfficacious(row, set, stat, lp, root) + ccall((:SCIProwIsLPEfficacious, libscip), Cuint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}, Cuint), row, set, stat, lp, root) +end -const SYM_EXPRDATA = SYM_Exprdata +function SCIProwGetSolEfficacy(row, set, stat, sol) + ccall((:SCIProwGetSolEfficacy, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), row, set, stat, sol) +end -@enum SCIP_LeaderRule::UInt32 begin - SCIP_LEADERRULE_FIRSTINORBIT = 0 - SCIP_LEADERRULE_LASTINORBIT = 1 - SCIP_LEADERRULE_MAXCONFLICTSINORBIT = 2 - SCIP_LEADERRULE_MAXCONFLICTS = 3 +function SCIProwIsSolEfficacious(row, set, stat, sol, root) + ccall((:SCIProwIsSolEfficacious, libscip), Cuint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Cuint), row, set, stat, sol, root) end -const SCIP_LEADERRULE = SCIP_LeaderRule +function SCIProwGetRelaxEfficacy(row, set, stat) + ccall((:SCIProwGetRelaxEfficacy, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) +end -@enum SCIP_LeaderTiebreakRule::UInt32 begin - SCIP_LEADERTIEBREAKRULE_MINORBIT = 0 - SCIP_LEADERTIEBREAKRULE_MAXORBIT = 1 - SCIP_LEADERTIEBREAKRULE_MAXCONFLICTSINORBIT = 2 +function SCIProwGetNLPEfficacy(row, set, stat) + ccall((:SCIProwGetNLPEfficacy, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) end -@enum SCIP_SSTType::UInt32 begin - SCIP_SSTTYPE_BINARY = 1 - SCIP_SSTTYPE_INTEGER = 2 - SCIP_SSTTYPE_IMPLINT = 4 - SCIP_SSTTYPE_CONTINUOUS = 8 +function SCIProwGetObjParallelism(row, set, lp) + ccall((:SCIProwGetObjParallelism, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), row, set, lp) end -const SCIP_SSTTYPE = SCIP_SSTType +function SCIProwCatchEvent(row, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) + ccall((:SCIProwCatchEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), row, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) +end -@enum SCIP_OrbitopeType::UInt32 begin - SCIP_ORBITOPETYPE_FULL = 0 - SCIP_ORBITOPETYPE_PARTITIONING = 1 - SCIP_ORBITOPETYPE_PACKING = 2 +function SCIProwDropEvent(row, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) + ccall((:SCIProwDropEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), row, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) end -const SCIP_ORBITOPETYPE = SCIP_OrbitopeType +function SCIProwMarkNotRemovableLocal(row, stat) + ccall((:SCIProwMarkNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), row, stat) +end -@enum SCIP_RecomputesymType::UInt32 begin - SCIP_RECOMPUTESYM_NEVER = 0 - SCIP_RECOMPUTESYM_ALWAYS = 1 - SCIP_RECOMPUTESYM_OFFOUNDRED = 2 +function SCIPlpCreate(lp, set, messagehdlr, stat, name) + ccall((:SCIPlpCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LP}}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{Cchar}), lp, set, messagehdlr, stat, name) end -const SCIP_RECOMPUTESYMTYPE = SCIP_RecomputesymType +function SCIPlpFree(lp, blkmem, set, eventqueue, eventfilter) + ccall((:SCIPlpFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LP}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, eventqueue, eventfilter) +end -function SCIPincludeConshdlrOrbitope(scip) - ccall( - (:SCIPincludeConshdlrOrbitope, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPcreateConsOrbitope( - scip, - cons, - name, - vars, - orbitopetype, - nspcons, - nblocks, - usedynamicprop, - mayinteract, - resolveprop, - ismodelcons, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, -) - ccall( - (:SCIPcreateConsOrbitope, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - SCIP_ORBITOPETYPE, - Cint, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - vars, - orbitopetype, - nspcons, - nblocks, - usedynamicprop, - mayinteract, - resolveprop, - ismodelcons, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) -end - -function SCIPcreateConsBasicOrbitope( - scip, - cons, - name, - vars, - orbitopetype, - nspcons, - nblocks, - usedynamicprop, - resolveprop, - ismodelcons, - mayinteract, -) - ccall( - (:SCIPcreateConsBasicOrbitope, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - SCIP_ORBITOPETYPE, - Cint, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - vars, - orbitopetype, - nspcons, - nblocks, - usedynamicprop, - resolveprop, - ismodelcons, - mayinteract, - ) +function SCIPlpReset(lp, blkmem, set, prob, stat, eventqueue, eventfilter) + ccall((:SCIPlpReset, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, prob, stat, eventqueue, eventfilter) end -function SCIPincludeConshdlrPseudoboolean(scip) - ccall( - (:SCIPincludeConshdlrPseudoboolean, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpAddCol(lp, set, col, depth) + ccall((:SCIPlpAddCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_COL}, Cint), lp, set, col, depth) end -@enum SCIP_LinearConsType::Int32 begin - SCIP_LINEARCONSTYPE_INVALIDCONS = -1 - SCIP_LINEARCONSTYPE_LINEAR = 0 - SCIP_LINEARCONSTYPE_LOGICOR = 1 - SCIP_LINEARCONSTYPE_KNAPSACK = 2 - SCIP_LINEARCONSTYPE_SETPPC = 3 +function SCIPlpAddRow(lp, blkmem, set, eventqueue, eventfilter, row, depth) + ccall((:SCIPlpAddRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_ROW}, Cint), lp, blkmem, set, eventqueue, eventfilter, row, depth) end -const SCIP_LINEARCONSTYPE = SCIP_LinearConsType +function SCIPlpShrinkCols(lp, set, newncols) + ccall((:SCIPlpShrinkCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Cint), lp, set, newncols) +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}}, - Ptr{Cchar}, - Ptr{SCIP_CONS}, - SCIP_LINEARCONSTYPE, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cdouble}, - Cint, - Ptr{SCIP_VAR}, - Cdouble, - Cuint, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Cdouble}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{SCIP_VAR}, - Cdouble, - Cuint, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Cdouble}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Cint, - Ptr{Cint}, - Ptr{Cdouble}, - Ptr{SCIP_VAR}, - Cdouble, - Cuint, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - ), - scip, - cons, - name, - linvars, - nlinvars, - linvals, - terms, - nterms, - ntermvars, - termvals, - indvar, - weight, - issoftcons, - intvar, - lhs, - rhs, - ) +function SCIPlpShrinkRows(lp, blkmem, set, eventqueue, eventfilter, newnrows) + ccall((:SCIPlpShrinkRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Cint), lp, blkmem, set, eventqueue, eventfilter, newnrows) 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, - ) +function SCIPlpClear(lp, blkmem, set, eventqueue, eventfilter) + ccall((:SCIPlpClear, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, eventqueue, eventfilter) 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, - ) +function SCIPlpMarkSize(lp) + ccall((:SCIPlpMarkSize, libscip), Cvoid, (Ptr{SCIP_LP},), lp) end -function SCIPgetIndVarPseudoboolean(scip, cons) - ccall( - (:SCIPgetIndVarPseudoboolean, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpSetSizeMark(lp, nrows, ncols) + ccall((:SCIPlpSetSizeMark, libscip), Cvoid, (Ptr{SCIP_LP}, Cint, Cint), lp, nrows, ncols) end -function SCIPgetLinearConsPseudoboolean(scip, cons) - ccall( - (:SCIPgetLinearConsPseudoboolean, libscip), - Ptr{SCIP_CONS}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetBasisInd(lp, basisind) + ccall((:SCIPlpGetBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{Cint}), lp, basisind) end -function SCIPgetLinearConsTypePseudoboolean(scip, cons) - ccall( - (:SCIPgetLinearConsTypePseudoboolean, libscip), - SCIP_LINEARCONSTYPE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetBase(lp, cstat, rstat) + ccall((:SCIPlpGetBase, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{Cint}, Ptr{Cint}), lp, cstat, rstat) 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, - ) +function SCIPlpGetBInvRow(lp, r, coef, inds, ninds) + ccall((:SCIPlpGetBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lp, r, coef, inds, ninds) 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, - ) +function SCIPlpGetBInvCol(lp, c, coef, inds, ninds) + ccall((:SCIPlpGetBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lp, c, coef, inds, ninds) end -function SCIPgetNAndsPseudoboolean(scip, cons) - ccall( - (:SCIPgetNAndsPseudoboolean, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetBInvARow(lp, r, binvrow, coef, inds, ninds) + ccall((:SCIPlpGetBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lp, r, binvrow, coef, inds, ninds) end -function SCIPchgLhsPseudoboolean(scip, cons, lhs) - ccall( - (:SCIPchgLhsPseudoboolean, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), - scip, - cons, - lhs, - ) +function SCIPlpGetBInvACol(lp, c, coef, inds, ninds) + ccall((:SCIPlpGetBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lp, c, coef, inds, ninds) end -function SCIPchgRhsPseudoboolean(scip, cons, rhs) - ccall( - (:SCIPchgRhsPseudoboolean, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), - scip, - cons, - rhs, - ) +function SCIPlpSumRows(lp, set, prob, weights, sumcoef, sumlhs, sumrhs) + ccall((:SCIPlpSumRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{Cdouble}, Ptr{SCIP_REALARRAY}, Ptr{Cdouble}, Ptr{Cdouble}), lp, set, prob, weights, sumcoef, sumlhs, sumrhs) end -function SCIPgetLhsPseudoboolean(scip, cons) - ccall( - (:SCIPgetLhsPseudoboolean, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetState(lp, blkmem, lpistate) + ccall((:SCIPlpGetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lp, blkmem, lpistate) end -function SCIPgetRhsPseudoboolean(scip, cons) - ccall( - (:SCIPgetRhsPseudoboolean, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpSetState(lp, blkmem, set, prob, eventqueue, lpistate, wasprimfeas, wasprimchecked, wasdualfeas, wasdualchecked) + ccall((:SCIPlpSetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPISTATE}, Cuint, Cuint, Cuint, Cuint), lp, blkmem, set, prob, eventqueue, lpistate, wasprimfeas, wasprimchecked, wasdualfeas, wasdualchecked) end -function SCIPincludeConshdlrSetppc(scip) - ccall( - (:SCIPincludeConshdlrSetppc, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpFreeState(lp, blkmem, lpistate) + ccall((:SCIPlpFreeState, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lp, blkmem, lpistate) end -@enum SCIP_SetppcType::UInt32 begin - SCIP_SETPPCTYPE_PARTITIONING = 0 - SCIP_SETPPCTYPE_PACKING = 1 - SCIP_SETPPCTYPE_COVERING = 2 +function SCIPlpInterrupt(lp, interrupt) + ccall((:SCIPlpInterrupt, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cuint), lp, interrupt) end -const SCIP_SETPPCTYPE = SCIP_SetppcType +function SCIPlpGetNorms(lp, blkmem, lpinorms) + ccall((:SCIPlpGetNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), lp, blkmem, lpinorms) +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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nvars, - vars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) +function SCIPlpSetNorms(lp, blkmem, lpinorms) + ccall((:SCIPlpSetNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPINORMS}), lp, blkmem, lpinorms) end -function SCIPcreateConsBasicSetpart(scip, cons, name, nvars, vars) - ccall( - (:SCIPcreateConsBasicSetpart, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nvars, - vars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) +function SCIPlpFreeNorms(lp, blkmem, lpinorms) + ccall((:SCIPlpFreeNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), lp, blkmem, lpinorms) end -function SCIPcreateConsBasicSetpack(scip, cons, name, nvars, vars) - ccall( - (:SCIPcreateConsBasicSetpack, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nvars, - vars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) +function SCIPlpGetCutoffbound(lp) + ccall((:SCIPlpGetCutoffbound, libscip), Cdouble, (Ptr{SCIP_LP},), lp) end -function SCIPcreateConsBasicSetcover(scip, cons, name, nvars, vars) - ccall( - (:SCIPcreateConsBasicSetcover, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}), - scip, - cons, - name, - nvars, - vars, - ) +function SCIPlpSetCutoffbound(lp, set, prob, cutoffbound) + ccall((:SCIPlpSetCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Cdouble), lp, set, prob, cutoffbound) end -function SCIPaddCoefSetppc(scip, cons, var) - ccall( - (:SCIPaddCoefSetppc, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), - scip, - cons, - var, - ) +function SCIPlpGetFeastol(lp) + ccall((:SCIPlpGetFeastol, libscip), Cdouble, (Ptr{SCIP_LP},), lp) end -function SCIPgetNVarsSetppc(scip, cons) - ccall( - (:SCIPgetNVarsSetppc, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpSetFeastol(lp, set, newfeastol) + ccall((:SCIPlpSetFeastol, libscip), Cvoid, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Cdouble), lp, set, newfeastol) end -function SCIPgetVarsSetppc(scip, cons) - ccall( - (:SCIPgetVarsSetppc, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpResetFeastol(lp, set) + ccall((:SCIPlpResetFeastol, libscip), Cvoid, (Ptr{SCIP_LP}, Ptr{SCIP_SET}), lp, set) end -function SCIPgetTypeSetppc(scip, cons) - ccall( - (:SCIPgetTypeSetppc, libscip), - SCIP_SETPPCTYPE, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpFlush(lp, blkmem, set, prob, eventqueue) + ccall((:SCIPlpFlush, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_EVENTQUEUE}), lp, blkmem, set, prob, eventqueue) end -function SCIPgetDualsolSetppc(scip, cons) - ccall( - (:SCIPgetDualsolSetppc, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpMarkFlushed(lp, set) + ccall((:SCIPlpMarkFlushed, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}), lp, set) end -function SCIPgetDualfarkasSetppc(scip, cons) - ccall( - (:SCIPgetDualfarkasSetppc, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, itlim, limitresolveiters, aging, keepsol, forcedlpsolve, lperror) + ccall((:SCIPlpSolveAndEval, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_PROB}, Clonglong, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, itlim, limitresolveiters, aging, keepsol, forcedlpsolve, lperror) end -function SCIPgetRowSetppc(scip, cons) - ccall( - (:SCIPgetRowSetppc, libscip), - Ptr{SCIP_ROW}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetSolstat(lp) + ccall((:SCIPlpGetSolstat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP_LP},), lp) end -function SCIPgetNFixedonesSetppc(scip, cons) - ccall( - (:SCIPgetNFixedonesSetppc, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpSetRootLPIsRelax(lp, isrelax) + ccall((:SCIPlpSetRootLPIsRelax, libscip), Cvoid, (Ptr{SCIP_LP}, Cuint), lp, isrelax) end -function SCIPgetNFixedzerosSetppc(scip, cons) - ccall( - (:SCIPgetNFixedzerosSetppc, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) -end - -function SCIPcleanupConssSetppc( - scip, - onlychecked, - infeasible, - naddconss, - ndelconss, - nchgcoefs, - nfixedvars, -) - ccall( - (:SCIPcleanupConssSetppc, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Cuint, - Ptr{Cuint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - onlychecked, - infeasible, - naddconss, - ndelconss, - nchgcoefs, - nfixedvars, - ) +function SCIPlpIsRootLPRelax(lp) + ccall((:SCIPlpIsRootLPRelax, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPincludeConshdlrSOS1(scip) - ccall((:SCIPincludeConshdlrSOS1, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpGetObjval(lp, set, prob) + ccall((:SCIPlpGetObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nvars, - vars, - weights, - initial, - separate, - enforce, - check, - propagate, - _local, - dynamic, - removable, - stickingatnode, - ) +function SCIPlpGetColumnObjval(lp) + ccall((:SCIPlpGetColumnObjval, libscip), Cdouble, (Ptr{SCIP_LP},), lp) end -function SCIPcreateConsBasicSOS1(scip, cons, name, nvars, vars, weights) - ccall( - (:SCIPcreateConsBasicSOS1, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - ), - scip, - cons, - name, - nvars, - vars, - weights, - ) +function SCIPlpGetLooseObjval(lp, set, prob) + ccall((:SCIPlpGetLooseObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) 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, - ) +function SCIPlpStoreRootObjval(lp, set, prob) + ccall((:SCIPlpStoreRootObjval, libscip), Cvoid, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) end -function SCIPappendVarSOS1(scip, cons, var) - ccall( - (:SCIPappendVarSOS1, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), - scip, - cons, - var, - ) +function SCIPlpInvalidateRootObjval(lp) + ccall((:SCIPlpInvalidateRootObjval, libscip), Cvoid, (Ptr{SCIP_LP},), lp) end -function SCIPgetNVarsSOS1(scip, cons) - ccall( - (:SCIPgetNVarsSOS1, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetGlobalPseudoObjval(lp, set, prob) + ccall((:SCIPlpGetGlobalPseudoObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) end -function SCIPgetVarsSOS1(scip, cons) - ccall( - (:SCIPgetVarsSOS1, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpRecomputeLocalAndGlobalPseudoObjval(lp, set, prob) + ccall((:SCIPlpRecomputeLocalAndGlobalPseudoObjval, libscip), Cvoid, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) end -function SCIPgetWeightsSOS1(scip, cons) - ccall( - (:SCIPgetWeightsSOS1, libscip), - Ptr{Cdouble}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetPseudoObjval(lp, set, prob) + ccall((:SCIPlpGetPseudoObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) end -function SCIPgetConflictgraphSOS1(conshdlr) - ccall( - (:SCIPgetConflictgraphSOS1, libscip), - Ptr{SCIP_DIGRAPH}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPlpGetModifiedPseudoObjval(lp, set, prob, var, oldbound, newbound, boundtype) + ccall((:SCIPlpGetModifiedPseudoObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_VAR}, Cdouble, Cdouble, SCIP_BOUNDTYPE), lp, set, prob, var, oldbound, newbound, boundtype) end -function SCIPgetNSOS1Vars(conshdlr) - ccall((:SCIPgetNSOS1Vars, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +function SCIPlpUpdateVarObj(lp, set, var, oldobj, newobj) + ccall((:SCIPlpUpdateVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldobj, newobj) end -function SCIPvarIsSOS1(conshdlr, var) - ccall( - (:SCIPvarIsSOS1, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}), - conshdlr, - var, - ) +function SCIPlpUpdateVarLbGlobal(lp, set, var, oldlb, newlb) + ccall((:SCIPlpUpdateVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldlb, newlb) end -function SCIPvarGetNodeSOS1(conshdlr, var) - ccall( - (:SCIPvarGetNodeSOS1, libscip), - Cint, - (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}), - conshdlr, - var, - ) +function SCIPlpUpdateVarLb(lp, set, var, oldlb, newlb) + ccall((:SCIPlpUpdateVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldlb, newlb) end -function SCIPnodeGetVarSOS1(conflictgraph, node) - ccall( - (:SCIPnodeGetVarSOS1, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_DIGRAPH}, Cint), - conflictgraph, - node, - ) +function SCIPlpUpdateVarUbGlobal(lp, set, var, oldub, newub) + ccall((:SCIPlpUpdateVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldub, newub) end -function SCIPmakeSOS1sFeasible(scip, conshdlr, sol, changed, success) - ccall( - (:SCIPmakeSOS1sFeasible, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_SOL}, Ptr{Cuint}, Ptr{Cuint}), - scip, - conshdlr, - sol, - changed, - success, - ) +function SCIPlpUpdateVarUb(lp, set, var, oldub, newub) + ccall((:SCIPlpUpdateVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldub, newub) end -function SCIPincludeConshdlrSOS2(scip) - ccall((:SCIPincludeConshdlrSOS2, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpUpdateAddVar(lp, set, var) + ccall((:SCIPlpUpdateAddVar, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lp, set, var) 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}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - nvars, - vars, - weights, - initial, - separate, - enforce, - check, - propagate, - _local, - dynamic, - removable, - stickingatnode, - ) +function SCIPlpUpdateDelVar(lp, set, var) + ccall((:SCIPlpUpdateDelVar, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lp, set, var) end -function SCIPcreateConsBasicSOS2(scip, cons, name, nvars, vars, weights) - ccall( - (:SCIPcreateConsBasicSOS2, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - ), - scip, - cons, - name, - nvars, - vars, - weights, - ) +function SCIPlpUpdateVarColumn(lp, set, var) + ccall((:SCIPlpUpdateVarColumn, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lp, set, var) 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, - ) +function SCIPlpUpdateVarLoose(lp, set, var) + ccall((:SCIPlpUpdateVarLoose, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lp, set, var) end -function SCIPappendVarSOS2(scip, cons, var) - ccall( - (:SCIPappendVarSOS2, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), - scip, - cons, - var, - ) +function SCIPlpDecNLoosevars(lp) + ccall((:SCIPlpDecNLoosevars, libscip), Cvoid, (Ptr{SCIP_LP},), lp) end -function SCIPgetNVarsSOS2(scip, cons) - ccall( - (:SCIPgetNVarsSOS2, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetSol(lp, set, stat, primalfeasible, dualfeasible) + ccall((:SCIPlpGetSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}), lp, set, stat, primalfeasible, dualfeasible) end -function SCIPgetVarsSOS2(scip, cons) - ccall( - (:SCIPgetVarsSOS2, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetUnboundedSol(lp, set, stat, primalfeasible, rayfeasible) + ccall((:SCIPlpGetUnboundedSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}), lp, set, stat, primalfeasible, rayfeasible) end -function SCIPgetWeightsSOS2(scip, cons) - ccall( - (:SCIPgetWeightsSOS2, libscip), - Ptr{Cdouble}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetPrimalRay(lp, set, ray) + ccall((:SCIPlpGetPrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cdouble}), lp, set, ray) end -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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{SCIP_CONS}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - binvar, - slackcons, - initial, - separate, - enforce, - check, - propagate, - _local, - dynamic, - removable, - stickingatnode, - ) +function SCIPlpGetDualfarkas(lp, set, stat, forcedlpsolve, valid) + ccall((:SCIPlpGetDualfarkas, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Cuint, Ptr{Cuint}), lp, set, stat, forcedlpsolve, valid) end -function SCIPcreateConsBasicSuperindicator(scip, cons, name, binvar, slackcons) - ccall( - (:SCIPcreateConsBasicSuperindicator, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{SCIP_CONS}, - ), - scip, - cons, - name, - binvar, - slackcons, - ) +function SCIPlpGetIterations(lp, iterations) + ccall((:SCIPlpGetIterations, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{Cint}), lp, iterations) end -function SCIPgetBinaryVarSuperindicator(cons) - ccall( - (:SCIPgetBinaryVarSuperindicator, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPlpUpdateAges(lp, stat) + ccall((:SCIPlpUpdateAges, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_STAT}), lp, stat) end -function SCIPgetSlackConsSuperindicator(cons) - ccall( - (:SCIPgetSlackConsSuperindicator, libscip), - Ptr{SCIP_CONS}, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPlpRemoveNewObsoletes(lp, blkmem, set, stat, eventqueue, eventfilter) + ccall((:SCIPlpRemoveNewObsoletes, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, stat, eventqueue, eventfilter) end -function SCIPtransformMinUC(scip, success) - ccall( - (:SCIPtransformMinUC, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cuint}), - scip, - success, - ) +function SCIPlpRemoveAllObsoletes(lp, blkmem, set, stat, eventqueue, eventfilter) + ccall((:SCIPlpRemoveAllObsoletes, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, stat, eventqueue, eventfilter) 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, - ) +function SCIPlpCleanupNew(lp, blkmem, set, stat, eventqueue, eventfilter, root) + ccall((:SCIPlpCleanupNew, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Cuint), lp, blkmem, set, stat, eventqueue, eventfilter, root) end -function SCIPincludeConshdlrSymresack(scip) - ccall( - (:SCIPincludeConshdlrSymresack, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPcreateSymbreakCons( - scip, - cons, - name, - perm, - vars, - nvars, - ismodelcons, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, -) - ccall( - (:SCIPcreateSymbreakCons, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{Cint}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - perm, - vars, - nvars, - ismodelcons, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) -end - -function SCIPcreateConsSymresack( - scip, - cons, - name, - perm, - vars, - nvars, - ismodelcons, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, -) - ccall( - (:SCIPcreateConsSymresack, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{Cint}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - perm, - vars, - nvars, - ismodelcons, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) -end - -function SCIPcreateConsBasicSymresack( - scip, - cons, - name, - perm, - vars, - nvars, - ismodelcons, -) - ccall( - (:SCIPcreateConsBasicSymresack, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Ptr{Cint}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cuint, - ), - scip, - cons, - name, - perm, - vars, - nvars, - ismodelcons, - ) +function SCIPlpCleanupAll(lp, blkmem, set, stat, eventqueue, eventfilter, root) + ccall((:SCIPlpCleanupAll, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Cuint), lp, blkmem, set, stat, eventqueue, eventfilter, root) end -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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - 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}}, - Ptr{Cchar}, - Ptr{SCIP_VAR}, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Cdouble, - ), - scip, - cons, - name, - var, - vbdvar, - vbdcoef, - lhs, - rhs, - ) +function SCIPlpRemoveRedundantRows(lp, blkmem, set, stat, eventqueue, eventfilter) + ccall((:SCIPlpRemoveRedundantRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, stat, eventqueue, eventfilter) end -function SCIPgetLhsVarbound(scip, cons) - ccall( - (:SCIPgetLhsVarbound, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpStartDive(lp, blkmem, set, stat) + ccall((:SCIPlpStartDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), lp, blkmem, set, stat) end -function SCIPgetRhsVarbound(scip, cons) - ccall( - (:SCIPgetRhsVarbound, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpEndDive(lp, blkmem, set, messagehdlr, stat, eventqueue, eventfilter, prob, vars, nvars) + ccall((:SCIPlpEndDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_PROB}, Ptr{Ptr{SCIP_VAR}}, Cint), lp, blkmem, set, messagehdlr, stat, eventqueue, eventfilter, prob, vars, nvars) end -function SCIPgetVarVarbound(scip, cons) - ccall( - (:SCIPgetVarVarbound, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpRecordOldRowSideDive(lp, row, sidetype) + ccall((:SCIPlpRecordOldRowSideDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_ROW}, SCIP_SIDETYPE), lp, row, sidetype) end -function SCIPgetVbdvarVarbound(scip, cons) - ccall( - (:SCIPgetVbdvarVarbound, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpStartProbing(lp) + ccall((:SCIPlpStartProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_LP},), lp) end -function SCIPgetVbdcoefVarbound(scip, cons) - ccall( - (:SCIPgetVbdcoefVarbound, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpEndProbing(lp) + ccall((:SCIPlpEndProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_LP},), lp) end -function SCIPgetDualsolVarbound(scip, cons) - ccall( - (:SCIPgetDualsolVarbound, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpStartStrongbranchProbing(lp) + ccall((:SCIPlpStartStrongbranchProbing, libscip), Cvoid, (Ptr{SCIP_LP},), lp) end -function SCIPgetDualfarkasVarbound(scip, cons) - ccall( - (:SCIPgetDualfarkasVarbound, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpEndStrongbranchProbing(lp) + ccall((:SCIPlpEndStrongbranchProbing, libscip), Cvoid, (Ptr{SCIP_LP},), lp) end -function SCIPgetRowVarbound(scip, cons) - ccall( - (:SCIPgetRowVarbound, libscip), - Ptr{SCIP_ROW}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) -end - -function SCIPcleanupConssVarbound( - scip, - onlychecked, - infeasible, - naddconss, - ndelconss, - nchgbds, -) - ccall( - (:SCIPcleanupConssVarbound, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), - scip, - onlychecked, - infeasible, - naddconss, - ndelconss, - nchgbds, - ) +function SCIPlpGetProvedLowerbound(lp, set, bound) + ccall((:SCIPlpGetProvedLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cdouble}), lp, set, bound) end -function SCIPincludeConshdlrXor(scip) - ccall((:SCIPincludeConshdlrXor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpIsInfeasibilityProved(lp, set, proved) + ccall((:SCIPlpIsInfeasibilityProved, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cuint}), lp, set, proved) 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}}, - Ptr{Cchar}, - Cuint, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - Cuint, - ), - scip, - cons, - name, - rhs, - nvars, - vars, - initial, - separate, - enforce, - check, - propagate, - _local, - modifiable, - dynamic, - removable, - stickingatnode, - ) +function SCIPlpWrite(lp, fname) + ccall((:SCIPlpWrite, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{Cchar}), lp, fname) end -function SCIPcreateConsBasicXor(scip, cons, name, rhs, nvars, vars) - ccall( - (:SCIPcreateConsBasicXor, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cchar}, - Cuint, - Cint, - Ptr{Ptr{SCIP_VAR}}, - ), - scip, - cons, - name, - rhs, - nvars, - vars, - ) +function SCIPlpWriteMip(lp, set, messagehdlr, fname, genericnames, origobj, objsense, objscale, objoffset, lazyconss) + ccall((:SCIPlpWriteMip, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cuint, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Cuint), lp, set, messagehdlr, fname, genericnames, origobj, objsense, objscale, objoffset, lazyconss) end -function SCIPgetNVarsXor(scip, cons) - ccall( - (:SCIPgetNVarsXor, libscip), - Cint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpRecalculateObjSqrNorm(set, lp) + ccall((:SCIPlpRecalculateObjSqrNorm, libscip), Cvoid, (Ptr{SCIP_SET}, Ptr{SCIP_LP}), set, lp) end -function SCIPgetVarsXor(scip, cons) - ccall( - (:SCIPgetVarsXor, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpComputeRelIntPoint(set, messagehdlr, lp, prob, relaxrows, inclobjcutoff, timelimit, iterlimit, point, success) + ccall((:SCIPlpComputeRelIntPoint, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_LP}, Ptr{SCIP_PROB}, Cuint, Cuint, Cdouble, Cint, Ptr{Cdouble}, Ptr{Cuint}), set, messagehdlr, lp, prob, relaxrows, inclobjcutoff, timelimit, iterlimit, point, success) end -function SCIPgetIntVarXor(scip, cons) - ccall( - (:SCIPgetIntVarXor, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetDualDegeneracy(lp, set, stat, degeneracy, varconsratio) + ccall((:SCIPlpGetDualDegeneracy, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cdouble}, Ptr{Cdouble}), lp, set, stat, degeneracy, varconsratio) end -function SCIPgetRhsXor(scip, cons) - ccall( - (:SCIPgetRhsXor, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPlpGetCols(lp) + ccall((:SCIPlpGetCols, libscip), Ptr{Ptr{SCIP_COL}}, (Ptr{SCIP_LP},), lp) end -function SCIPincludeConshdlrComponents(scip) - ccall( - (:SCIPincludeConshdlrComponents, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpGetNCols(lp) + ccall((:SCIPlpGetNCols, libscip), Cint, (Ptr{SCIP_LP},), lp) end -function SCIPincludeDispDefault(scip) - ccall((:SCIPincludeDispDefault, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpGetNUnfixedCols(lp, eps) + ccall((:SCIPlpGetNUnfixedCols, libscip), Cint, (Ptr{SCIP_LP}, Cdouble), lp, eps) end -function SCIPdialogExecMenu(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecMenu, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetRows(lp) + ccall((:SCIPlpGetRows, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecMenuLazy(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecMenuLazy, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetNRows(lp) + ccall((:SCIPlpGetNRows, libscip), Cint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecChangeAddCons(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecChangeAddCons, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetNewcols(lp) + ccall((:SCIPlpGetNewcols, libscip), Ptr{Ptr{SCIP_COL}}, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecChangeBounds(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecChangeBounds, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecChangeFreetransproblem( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecChangeFreetransproblem, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetNNewcols(lp) + ccall((:SCIPlpGetNNewcols, libscip), Cint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecChangeObjSense(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecChangeObjSense, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetNewrows(lp) + ccall((:SCIPlpGetNewrows, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecChecksol(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecChecksol, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetNNewrows(lp) + ccall((:SCIPlpGetNNewrows, libscip), Cint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecCliquegraph(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecCliquegraph, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetObjNorm(lp) + ccall((:SCIPlpGetObjNorm, libscip), Cdouble, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayBenders(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayBenders, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetRootObjval(lp) + ccall((:SCIPlpGetRootObjval, libscip), Cdouble, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayBranching(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayBranching, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetRootColumnObjval(lp) + ccall((:SCIPlpGetRootColumnObjval, libscip), Cdouble, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayCompression(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayCompression, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetRootLooseObjval(lp) + ccall((:SCIPlpGetRootLooseObjval, libscip), Cdouble, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayConflict(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayConflict, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpGetLPI(lp) + ccall((:SCIPlpGetLPI, libscip), Ptr{SCIP_LPI}, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayConshdlrs(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayConshdlrs, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpSetIsRelax(lp, relax) + ccall((:SCIPlpSetIsRelax, libscip), Cvoid, (Ptr{SCIP_LP}, Cuint), lp, relax) end -function SCIPdialogExecDisplayDisplaycols(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayDisplaycols, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsRelax(lp) + ccall((:SCIPlpIsRelax, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayExprhdlrs(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayExprhdlrs, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsSolved(lp) + ccall((:SCIPlpIsSolved, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayCutselectors(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayCutselectors, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsPrimalReliable(lp) + ccall((:SCIPlpIsPrimalReliable, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayHeuristics(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayHeuristics, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsDualReliable(lp) + ccall((:SCIPlpIsDualReliable, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayMemory(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayMemory, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecDisplayNodeselectors( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecDisplayNodeselectors, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsSolBasic(lp) + ccall((:SCIPlpIsSolBasic, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayNlpi(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayNlpi, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpDiving(lp) + ccall((:SCIPlpDiving, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayParameters(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayParameters, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpDivingObjChanged(lp) + ccall((:SCIPlpDivingObjChanged, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayPresolvers(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayPresolvers, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpMarkDivingObjChanged(lp) + ccall((:SCIPlpMarkDivingObjChanged, libscip), Cvoid, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayPricers(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayPricers, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpUnmarkDivingObjChanged(lp) + ccall((:SCIPlpUnmarkDivingObjChanged, libscip), Cvoid, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayProblem(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayProblem, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpDivingRowsChanged(lp) + ccall((:SCIPlpDivingRowsChanged, libscip), Cuint, (Ptr{SCIP_LP},), lp) end -function SCIPdialogExecDisplayPropagators(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayPropagators, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsFeasEQ(set, lp, val1, val2) + ccall((:SCIPlpIsFeasEQ, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) end -function SCIPdialogExecDisplayReaders(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayReaders, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsFeasLT(set, lp, val1, val2) + ccall((:SCIPlpIsFeasLT, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) end -function SCIPdialogExecDisplayRelaxators(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayRelaxators, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsFeasLE(set, lp, val1, val2) + ccall((:SCIPlpIsFeasLE, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) end -function SCIPdialogExecDisplaySeparators(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplaySeparators, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsFeasGT(set, lp, val1, val2) + ccall((:SCIPlpIsFeasGT, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) end -function SCIPdialogExecDisplaySolution(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplaySolution, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecDisplayFiniteSolution( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecDisplayFiniteSolution, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsFeasGE(set, lp, val1, val2) + ccall((:SCIPlpIsFeasGE, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) end -function SCIPdialogExecDisplayDualSolution(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayDualSolution, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsFeasZero(lp, val) + ccall((:SCIPlpIsFeasZero, libscip), Cuint, (Ptr{SCIP_LP}, Cdouble), lp, val) end -function SCIPdialogExecDisplaySolutionPool(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplaySolutionPool, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsFeasPositive(lp, val) + ccall((:SCIPlpIsFeasPositive, libscip), Cuint, (Ptr{SCIP_LP}, Cdouble), lp, val) end -function SCIPdialogExecDisplaySubproblem(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplaySubproblem, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPlpIsFeasNegative(lp, val) + ccall((:SCIPlpIsFeasNegative, libscip), Cuint, (Ptr{SCIP_LP}, Cdouble), lp, val) end -function SCIPdialogExecDisplaySubSolution(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplaySubSolution, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCreate(rational) + ccall((:SCIPrationalCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONAL}},), rational) end -function SCIPdialogExecDisplayStatistics(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayStatistics, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecDisplayReoptStatistics( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecDisplayReoptStatistics, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCreateBuffer(bufmem, rational) + ccall((:SCIPrationalCreateBuffer, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}), bufmem, rational) end -function SCIPdialogExecDisplayTransproblem(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayTransproblem, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCreateBlock(blkmem, rational) + ccall((:SCIPrationalCreateBlock, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}), blkmem, rational) end -function SCIPdialogExecDisplayValue(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecDisplayValue, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecDisplayVarbranchstatistics( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecDisplayVarbranchstatistics, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecDisplayLPSolutionQuality( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecDisplayLPSolutionQuality, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecDisplayTranssolution( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecDisplayTranssolution, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCopy(result, src) + ccall((:SCIPrationalCopy, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), result, src) end -function SCIPdialogExecHelp(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecHelp, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCopyBlock(mem, result, src) + ccall((:SCIPrationalCopyBlock, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), mem, result, src) end -function SCIPdialogExecFree(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecFree, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCopyBuffer(bufmem, result, src) + ccall((:SCIPrationalCopyBuffer, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), bufmem, result, src) end -function SCIPdialogExecNewstart(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecNewstart, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCreateArray(rational, size) + ccall((:SCIPrationalCreateArray, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), rational, size) end -function SCIPdialogExecTransform(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecTransform, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCreateBlockArray(mem, rational, size) + ccall((:SCIPrationalCreateBlockArray, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), mem, rational, size) end -function SCIPdialogExecOptimize(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecOptimize, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCreateBufferArray(mem, rational, size) + ccall((:SCIPrationalCreateBufferArray, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), mem, rational, size) end -function SCIPdialogExecConcurrentOpt(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecConcurrentOpt, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCopyArray(target, src, len) + ccall((:SCIPrationalCopyArray, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint), target, src, len) end -function SCIPdialogExecPresolve(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecPresolve, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCopyBlockArray(mem, target, src, len) + ccall((:SCIPrationalCopyBlockArray, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint), mem, target, src, len) end -function SCIPdialogExecQuit(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecQuit, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCopyBufferArray(mem, result, src, len) + ccall((:SCIPrationalCopyBufferArray, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint), mem, result, src, len) end -function SCIPdialogExecRead(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecRead, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalReallocArray(result, oldlen, newlen) + ccall((:SCIPrationalReallocArray, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), result, oldlen, newlen) end -function SCIPdialogExecSetDefault(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetDefault, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalReallocBufferArray(mem, result, oldlen, newlen) + ccall((:SCIPrationalReallocBufferArray, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), mem, result, oldlen, newlen) end -function SCIPdialogExecSetLoad(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetLoad, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalReallocBlockArray(mem, result, oldlen, newlen) + ccall((:SCIPrationalReallocBlockArray, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), mem, result, oldlen, newlen) end -function SCIPdialogExecSetSave(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetSave, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalFree(rational) + ccall((:SCIPrationalFree, libscip), Cvoid, (Ptr{Ptr{SCIP_RATIONAL}},), rational) end -function SCIPdialogExecSetDiffsave(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetDiffsave, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalFreeBlock(mem, rational) + ccall((:SCIPrationalFreeBlock, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}), mem, rational) end -function SCIPdialogExecSetParam(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetParam, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalFreeBuffer(bufmem, rational) + ccall((:SCIPrationalFreeBuffer, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}), bufmem, rational) end -function SCIPdialogDescSetParam(scip, dialog) - ccall( - (:SCIPdialogDescSetParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DIALOG}), - scip, - dialog, - ) +function SCIPrationalFreeArray(ratarray, size) + ccall((:SCIPrationalFreeArray, libscip), Cvoid, (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), ratarray, size) end -function SCIPdialogExecFixParam(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecFixParam, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalFreeBlockArray(mem, ratblockarray, size) + ccall((:SCIPrationalFreeBlockArray, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), mem, ratblockarray, size) end -function SCIPdialogDescFixParam(scip, dialog) - ccall( - (:SCIPdialogDescFixParam, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_DIALOG}), - scip, - dialog, - ) -end - -function SCIPdialogExecSetBranchingDirection( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetBranchingDirection, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetBranchingPriority( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetBranchingPriority, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetHeuristicsAggressive( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetHeuristicsAggressive, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetHeuristicsDefault( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetHeuristicsDefault, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalFreeBufferArray(mem, ratbufarray, size) + ccall((:SCIPrationalFreeBufferArray, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), mem, ratbufarray, size) end -function SCIPdialogExecSetHeuristicsFast(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetHeuristicsFast, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalSetRational(res, src) + ccall((:SCIPrationalSetRational, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, src) end -function SCIPdialogExecSetHeuristicsOff(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetHeuristicsOff, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetPresolvingAggressive( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetPresolvingAggressive, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetPresolvingDefault( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetPresolvingDefault, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalSetFraction(res, nom, denom) + ccall((:SCIPrationalSetFraction, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Clonglong, Clonglong), res, nom, denom) end -function SCIPdialogExecSetPresolvingFast(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetPresolvingFast, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalSetReal(res, real) + ccall((:SCIPrationalSetReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Cdouble), res, real) end -function SCIPdialogExecSetPresolvingOff(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetPresolvingOff, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetSeparatingAggressive( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetSeparatingAggressive, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetSeparatingDefault( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetSeparatingDefault, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalSetInfinity(res) + ccall((:SCIPrationalSetInfinity, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), res) end -function SCIPdialogExecSetSeparatingFast(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetSeparatingFast, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalSetNegInfinity(res) + ccall((:SCIPrationalSetNegInfinity, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), res) end -function SCIPdialogExecSetSeparatingOff(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetSeparatingOff, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalIsString(desc) + ccall((:SCIPrationalIsString, libscip), Cuint, (Ptr{Cchar},), desc) end -function SCIPdialogExecSetEmphasisCounter(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetEmphasisCounter, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalSetString(res, desc) + ccall((:SCIPrationalSetString, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{Cchar}), res, desc) end -function SCIPdialogExecSetEmphasisCpsolver(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetEmphasisCpsolver, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCreateString(mem, rational, desc) + ccall((:SCIPrationalCreateString, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Cchar}), mem, rational, desc) end -function SCIPdialogExecSetEmphasisEasycip(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetEmphasisEasycip, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetEmphasisFeasibility( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetEmphasisFeasibility, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPstrToRationalValue(desc, value, endptr) + ccall((:SCIPstrToRationalValue, libscip), Cuint, (Ptr{Cchar}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{Cchar}}), desc, value, endptr) end -function SCIPdialogExecSetEmphasisHardlp(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetEmphasisHardlp, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetEmphasisOptimality( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetEmphasisOptimality, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalResetFloatingPointRepresentable(rat) + ccall((:SCIPrationalResetFloatingPointRepresentable, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), rat) end -function SCIPdialogExecSetEmphasisNumerics(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetEmphasisNumerics, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecSetEmphasisBenchmark( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecSetEmphasisBenchmark, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCanonicalize(rational) + ccall((:SCIPrationalCanonicalize, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPdialogExecSetLimitsObjective(scip, dialog, dialoghdlr, nextdialog) - ccall( - (:SCIPdialogExecSetLimitsObjective, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) -end - -function SCIPdialogExecDisplayLinearConsClassification( - scip, - dialog, - dialoghdlr, - nextdialog, -) - ccall( - (:SCIPdialogExecDisplayLinearConsClassification, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_DIALOG}, - Ptr{SCIP_DIALOGHDLR}, - Ptr{Ptr{SCIP_DIALOG}}, - ), - scip, - dialog, - dialoghdlr, - nextdialog, - ) +function SCIPrationalCheckInfByValue(rational) + ccall((:SCIPrationalCheckInfByValue, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPcreateRootDialog(scip, root) - ccall( - (:SCIPcreateRootDialog, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), - scip, - root, - ) +function SCIPrationalAdd(res, op1, op2) + ccall((:SCIPrationalAdd, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) end -function SCIPincludeDialogDefaultBasic(scip) - ccall( - (:SCIPincludeDialogDefaultBasic, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalAddReal(res, rat, real) + ccall((:SCIPrationalAddReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, rat, real) end -function SCIPincludeDialogDefaultSet(scip) - ccall( - (:SCIPincludeDialogDefaultSet, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalDiff(res, op1, op2) + ccall((:SCIPrationalDiff, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) end -function SCIPincludeDialogDefaultFix(scip) - ccall( - (:SCIPincludeDialogDefaultFix, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalDiffReal(res, rat, real) + ccall((:SCIPrationalDiffReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, rat, real) end -function SCIPincludeEventHdlrEstim(scip) - ccall( - (:SCIPincludeEventHdlrEstim, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalRelDiff(res, val1, val2) + ccall((:SCIPrationalRelDiff, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, val1, val2) end -function SCIPgetTreesizeEstimation(scip) - ccall((:SCIPgetTreesizeEstimation, libscip), Cdouble, (Ptr{SCIP},), scip) +function SCIPrationalMult(res, op1, op2) + ccall((:SCIPrationalMult, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) end -function SCIPincludeEventHdlrSolvingphase(scip) - ccall( - (:SCIPincludeEventHdlrSolvingphase, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalMultReal(res, op1, op2) + ccall((:SCIPrationalMultReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, op1, op2) end -function SCIPincludeEventHdlrSofttimelimit(scip) - ccall( - (:SCIPincludeEventHdlrSofttimelimit, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalDiv(res, op1, op2) + ccall((:SCIPrationalDiv, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) end -function SCIPcreateExprAbs(scip, expr, child, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprAbs, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPR}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - child, - ownercreate, - ownercreatedata, - ) +function SCIPrationalDivReal(res, op1, op2) + ccall((:SCIPrationalDivReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, op1, op2) end -function SCIPincludeExprhdlrAbs(scip) - ccall((:SCIPincludeExprhdlrAbs, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalAddProd(res, op1, op2) + ccall((:SCIPrationalAddProd, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) end -function SCIPincludeExprhdlrEntropy(scip) - ccall( - (:SCIPincludeExprhdlrEntropy, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalAddProdReal(res, op1, op2) + ccall((:SCIPrationalAddProdReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, op1, op2) end -function SCIPcreateExprEntropy(scip, expr, child, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprEntropy, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPR}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - child, - ownercreate, - ownercreatedata, - ) +function SCIPrationalDiffProd(res, op1, op2) + ccall((:SCIPrationalDiffProd, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) end -function SCIPcreateExprExp(scip, expr, child, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprExp, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPR}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - child, - ownercreate, - ownercreatedata, - ) +function SCIPrationalDiffProdReal(res, op1, op2) + ccall((:SCIPrationalDiffProdReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, op1, op2) end -function SCIPisExprExp(scip, expr) - ccall( - (:SCIPisExprExp, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) +function SCIPrationalNegate(res, op) + ccall((:SCIPrationalNegate, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op) end -function SCIPincludeExprhdlrExp(scip) - ccall((:SCIPincludeExprhdlrExp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalAbs(res, op) + ccall((:SCIPrationalAbs, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op) end -function SCIPcreateExprLog(scip, expr, child, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprLog, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPR}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - child, - ownercreate, - ownercreatedata, - ) +function SCIPrationalInvert(res, op) + ccall((:SCIPrationalInvert, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op) end -function SCIPisExprLog(scip, expr) - ccall( - (:SCIPisExprLog, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) +function SCIPrationalMin(res, op1, op2) + ccall((:SCIPrationalMin, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) end -function SCIPincludeExprhdlrLog(scip) - ccall((:SCIPincludeExprhdlrLog, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalMax(res, op1, op2) + ccall((:SCIPrationalMax, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) end -function SCIPcreateExprPow( - scip, - expr, - child, - exponent, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcreateExprPow, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPR}, - Cdouble, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - child, - exponent, - ownercreate, - ownercreatedata, - ) -end - -function SCIPcreateExprSignpower( - scip, - expr, - child, - exponent, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcreateExprSignpower, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPR}, - Cdouble, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - child, - exponent, - ownercreate, - ownercreatedata, - ) +function SCIPrationalIsEQ(rat1, rat2) + ccall((:SCIPrationalIsEQ, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) end -function SCIPisExprSignpower(scip, expr) - ccall( - (:SCIPisExprSignpower, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) +function SCIPrationalIsAbsEQ(rat1, rat2) + ccall((:SCIPrationalIsAbsEQ, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) end -function SCIPincludeExprhdlrPow(scip) - ccall((:SCIPincludeExprhdlrPow, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalIsEQReal(rat, real) + ccall((:SCIPrationalIsEQReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) end -function SCIPincludeExprhdlrSignpower(scip) - ccall( - (:SCIPincludeExprhdlrSignpower, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPaddSquareLinearization( - scip, - sqrcoef, - refpoint, - isint, - lincoef, - linconstant, - success, -) - ccall( - (:SCIPaddSquareLinearization, libscip), - Cvoid, - ( - Ptr{SCIP}, - Cdouble, - Cdouble, - Cuint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - ), - scip, - sqrcoef, - refpoint, - isint, - lincoef, - linconstant, - success, - ) -end - -function SCIPaddSquareSecant( - scip, - sqrcoef, - lb, - ub, - lincoef, - linconstant, - success, -) - ccall( - (:SCIPaddSquareSecant, libscip), - Cvoid, - ( - Ptr{SCIP}, - Cdouble, - Cdouble, - Cdouble, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - ), - scip, - sqrcoef, - lb, - ub, - lincoef, - linconstant, - success, - ) +function SCIPrationalIsApproxEQReal(set, rat, real, roundmode) + ccall((:SCIPrationalIsApproxEQReal, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}, Cdouble, SCIP_ROUNDMODE_RAT), set, rat, real, roundmode) end -function SCIPincludeExprhdlrProduct(scip) - ccall( - (:SCIPincludeExprhdlrProduct, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPcreateExprProduct( - scip, - expr, - nchildren, - children, - coefficient, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcreateExprProduct, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Cint, - Ptr{Ptr{SCIP_EXPR}}, - Cdouble, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - nchildren, - children, - coefficient, - ownercreate, - ownercreatedata, - ) +function SCIPrationalIsGT(rat1, rat2) + ccall((:SCIPrationalIsGT, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) end -function SCIPincludeExprhdlrSum(scip) - ccall((:SCIPincludeExprhdlrSum, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalIsLT(rat1, rat2) + ccall((:SCIPrationalIsLT, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) end -function SCIPcreateExprSum( - scip, - expr, - nchildren, - children, - coefficients, - constant, - ownercreate, - ownercreatedata, -) - ccall( - (:SCIPcreateExprSum, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Cint, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cdouble}, - Cdouble, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - nchildren, - children, - coefficients, - constant, - ownercreate, - ownercreatedata, - ) +function SCIPrationalIsGE(rat1, rat2) + ccall((:SCIPrationalIsGE, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) end -function SCIPsetConstantExprSum(expr, constant) - ccall( - (:SCIPsetConstantExprSum, libscip), - Cvoid, - (Ptr{SCIP_EXPR}, Cdouble), - expr, - constant, - ) +function SCIPrationalIsLE(rat1, rat2) + ccall((:SCIPrationalIsLE, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) end -function SCIPappendExprSumExpr(scip, expr, child, childcoef) - ccall( - (:SCIPappendExprSumExpr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}, Cdouble), - scip, - expr, - child, - childcoef, - ) +function SCIPrationalIsAbsGT(rat1, rat2) + ccall((:SCIPrationalIsAbsGT, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) end -function SCIPmultiplyByConstantExprSum(expr, constant) - ccall( - (:SCIPmultiplyByConstantExprSum, libscip), - Cvoid, - (Ptr{SCIP_EXPR}, Cdouble), - expr, - constant, - ) +function SCIPrationalIsGTReal(rat, real) + ccall((:SCIPrationalIsGTReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) end -function SCIPincludeExprhdlrSin(scip) - ccall((:SCIPincludeExprhdlrSin, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalIsLTReal(rat, real) + ccall((:SCIPrationalIsLTReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) end -function SCIPincludeExprhdlrCos(scip) - ccall((:SCIPincludeExprhdlrCos, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalIsGEReal(rat, real) + ccall((:SCIPrationalIsGEReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) end -function SCIPcreateExprSin(scip, expr, child, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprSin, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPR}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - child, - ownercreate, - ownercreatedata, - ) +function SCIPrationalIsLEReal(rat, real) + ccall((:SCIPrationalIsLEReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) end -function SCIPcreateExprCos(scip, expr, child, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprCos, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{SCIP_EXPR}, - Ptr{Cvoid}, - Ptr{Cvoid}, - ), - scip, - expr, - child, - ownercreate, - ownercreatedata, - ) +function SCIPrationalIsZero(rational) + ccall((:SCIPrationalIsZero, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeExprhdlrValue(scip) - ccall( - (:SCIPincludeExprhdlrValue, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalIsPositive(rational) + ccall((:SCIPrationalIsPositive, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPcreateExprValue(scip, expr, value, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprValue, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), - scip, - expr, - value, - ownercreate, - ownercreatedata, - ) +function SCIPrationalIsNegative(rational) + ccall((:SCIPrationalIsNegative, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeExprhdlrVar(scip) - ccall((:SCIPincludeExprhdlrVar, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalIsInfinity(rational) + ccall((:SCIPrationalIsInfinity, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPcreateExprVar(scip, expr, var, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprVar, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_VAR}, Ptr{Cvoid}, Ptr{Cvoid}), - scip, - expr, - var, - ownercreate, - ownercreatedata, - ) +function SCIPrationalIsNegInfinity(rational) + ccall((:SCIPrationalIsNegInfinity, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurActconsdiving(scip) - ccall( - (:SCIPincludeHeurActconsdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalIsAbsInfinity(rational) + ccall((:SCIPrationalIsAbsInfinity, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurAdaptivediving(scip) - ccall( - (:SCIPincludeHeurAdaptivediving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalIsIntegral(rational) + ccall((:SCIPrationalIsIntegral, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurBound(scip) - ccall((:SCIPincludeHeurBound, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalIsFpRepresentable(rational) + ccall((:SCIPrationalIsFpRepresentable, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurClique(scip) - ccall((:SCIPincludeHeurClique, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalToString(rational, str, strlen) + ccall((:SCIPrationalToString, libscip), Cint, (Ptr{SCIP_RATIONAL}, Ptr{Cchar}, Cint), rational, str, strlen) end -function SCIPincludeHeurCoefdiving(scip) - ccall( - (:SCIPincludeHeurCoefdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalStrLen(rational) + ccall((:SCIPrationalStrLen, libscip), Cint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurCompletesol(scip) - ccall( - (:SCIPincludeHeurCompletesol, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalMessage(msg, file, rational) + ccall((:SCIPrationalMessage, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Ptr{SCIP_RATIONAL}), msg, file, rational) end -function SCIPincludeHeurConflictdiving(scip) - ccall( - (:SCIPincludeHeurConflictdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalPrintVerbInfo(msg, verblevel, msgverblevel, rational) + ccall((:SCIPrationalPrintVerbInfo, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, SCIP_VERBLEVEL, SCIP_VERBLEVEL, Ptr{SCIP_RATIONAL}), msg, verblevel, msgverblevel, rational) end -function SCIPincludeHeurCrossover(scip) - ccall( - (:SCIPincludeHeurCrossover, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalPrint(rational) + ccall((:SCIPrationalPrint, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurDins(scip) - ccall((:SCIPincludeHeurDins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalNumerator(rational) + ccall((:SCIPrationalNumerator, libscip), Clonglong, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurDistributiondiving(scip) - ccall( - (:SCIPincludeHeurDistributiondiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalDenominator(rational) + ccall((:SCIPrationalDenominator, libscip), Clonglong, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurDps(scip) - ccall((:SCIPincludeHeurDps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalDenominatorIsLE(rational, val) + ccall((:SCIPrationalDenominatorIsLE, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Clonglong), rational, val) end -function SCIPincludeHeurDualval(scip) - ccall((:SCIPincludeHeurDualval, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalGetSign(rational) + ccall((:SCIPrationalGetSign, libscip), Cint, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPapplyHeurDualval(scip, heur, result, refpoint) - ccall( - (:SCIPapplyHeurDualval, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Ptr{SCIP_SOL}), - scip, - heur, - result, - refpoint, - ) +function SCIPrationalGetFrac(res, src) + ccall((:SCIPrationalGetFrac, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, src) end -function SCIPincludeHeurFarkasdiving(scip) - ccall( - (:SCIPincludeHeurFarkasdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalGetReal(rational) + ccall((:SCIPrationalGetReal, libscip), Cdouble, (Ptr{SCIP_RATIONAL},), rational) end -function SCIPincludeHeurFeaspump(scip) - ccall((:SCIPincludeHeurFeaspump, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalRoundReal(rational, roundmode) + ccall((:SCIPrationalRoundReal, libscip), Cdouble, (Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), rational, roundmode) end -function SCIPincludeHeurFixandinfer(scip) - ccall( - (:SCIPincludeHeurFixandinfer, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalRoundInteger(res, src, roundmode) + ccall((:SCIPrationalRoundInteger, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), res, src, roundmode) end -function SCIPincludeHeurFracdiving(scip) - ccall( - (:SCIPincludeHeurFracdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalRoundLong(res, src, roundmode) + ccall((:SCIPrationalRoundLong, libscip), Cuint, (Ptr{Clonglong}, Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), res, src, roundmode) end -function SCIPincludeHeurGins(scip) - ccall((:SCIPincludeHeurGins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalComputeApproximation(res, src, maxdenom, forcegreater) + ccall((:SCIPrationalComputeApproximation, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Clonglong, Cint), res, src, maxdenom, forcegreater) end -function SCIPincludeHeurGuideddiving(scip) - ccall( - (:SCIPincludeHeurGuideddiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalarrayCreate(rationalarray, blkmem) + ccall((:SCIPrationalarrayCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONALARRAY}}, Ptr{BMS_BLKMEM}), rationalarray, blkmem) end -function SCIPincludeHeurIndicator(scip) - ccall( - (:SCIPincludeHeurIndicator, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalarrayResize(rationalarray, newsize) + ccall((:SCIPrationalarrayResize, libscip), SCIP_RETCODE, (Ptr{SCIP_RATIONALARRAY}, Cint), rationalarray, newsize) end -function SCIPheurPassIndicator(scip, heur, nindconss, indconss, solcand, obj) - ccall( - (:SCIPheurPassIndicator, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_HEUR}, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Ptr{Cuint}, - Cdouble, - ), - scip, - heur, - nindconss, - indconss, - solcand, - obj, - ) +function SCIPrationalarrayCopy(rationalarray, blkmem, sourcerationalarray) + ccall((:SCIPrationalarrayCopy, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONALARRAY}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_RATIONALARRAY}), rationalarray, blkmem, sourcerationalarray) end -function SCIPincludeHeurIntdiving(scip) - ccall( - (:SCIPincludeHeurIntdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalarrayFree(rationalarray, blkmem) + ccall((:SCIPrationalarrayFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONALARRAY}}, Ptr{BMS_BLKMEM}), rationalarray, blkmem) end -function SCIPincludeHeurIntshifting(scip) - ccall( - (:SCIPincludeHeurIntshifting, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalarrayGetVal(rationalarray, idx, result) + ccall((:SCIPrationalarrayGetVal, libscip), Cvoid, (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), rationalarray, idx, result) end -function SCIPincludeHeurLinesearchdiving(scip) - ccall( - (:SCIPincludeHeurLinesearchdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalarraySetVal(rationalarray, idx, val) + ccall((:SCIPrationalarraySetVal, libscip), SCIP_RETCODE, (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), rationalarray, idx, val) end -function SCIPincludeHeurLocalbranching(scip) - ccall( - (:SCIPincludeHeurLocalbranching, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalarrayIncVal(rationalarray, idx, incval) + ccall((:SCIPrationalarrayIncVal, libscip), SCIP_RETCODE, (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), rationalarray, idx, incval) end -function SCIPincludeHeurLocks(scip) - ccall((:SCIPincludeHeurLocks, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalarrayPrint(rationalarray) + ccall((:SCIPrationalarrayPrint, libscip), SCIP_RETCODE, (Ptr{SCIP_RATIONALARRAY},), rationalarray) end -function SCIPapplyLockFixings(scip, heurdata, cutoff, allrowsfulfilled) - ccall( - (:SCIPapplyLockFixings, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEURDATA}, Ptr{Cuint}, Ptr{Cuint}), - scip, - heurdata, - cutoff, - allrowsfulfilled, - ) +function SCIPrationalarrayGetMinIdx(rationalarray) + ccall((:SCIPrationalarrayGetMinIdx, libscip), Cint, (Ptr{SCIP_RATIONALARRAY},), rationalarray) end -function SCIPincludeHeurLpface(scip) - ccall((:SCIPincludeHeurLpface, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalarrayGetMaxIdx(rationalarray) + ccall((:SCIPrationalarrayGetMaxIdx, libscip), Cint, (Ptr{SCIP_RATIONALARRAY},), rationalarray) end -function SCIPincludeHeurAlns(scip) - ccall((:SCIPincludeHeurAlns, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPrationalChgInfinity(inf) + ccall((:SCIPrationalChgInfinity, libscip), Cvoid, (Cdouble,), inf) end -function SCIPincludeHeurMultistart(scip) - ccall( - (:SCIPincludeHeurMultistart, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPrationalGetInfinity() + ccall((:SCIPrationalGetInfinity, libscip), Cdouble, ()) end -function SCIPincludeHeurMutation(scip) - ccall((:SCIPincludeHeurMutation, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactCreate(col, fpcol, blkmem, set, stat, var, len, rows, vals, removable) + ccall((:SCIPcolExactCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COLEXACT}}, Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{Ptr{SCIP_RATIONAL}}, Cuint), col, fpcol, blkmem, set, stat, var, len, rows, vals, removable) end -function SCIPincludeHeurMpec(scip) - ccall((:SCIPincludeHeurMpec, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactFree(col, blkmem) + ccall((:SCIPcolExactFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COLEXACT}}, Ptr{BMS_BLKMEM}), col, blkmem) end -function SCIPincludeHeurNlpdiving(scip) - ccall( - (:SCIPincludeHeurNlpdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPcolExactPrint(col, messagehdlr, file) + ccall((:SCIPcolExactPrint, libscip), Cvoid, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), col, messagehdlr, file) end -function SCIPincludeHeurObjpscostdiving(scip) - ccall( - (:SCIPincludeHeurObjpscostdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPcolExactAddCoef(col, blkmem, set, eventqueue, lpexact, row, val) + ccall((:SCIPcolExactAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), col, blkmem, set, eventqueue, lpexact, row, val) end -function SCIPincludeHeurOctane(scip) - ccall((:SCIPincludeHeurOctane, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactDelCoef(col, set, lpexact, row) + ccall((:SCIPcolExactDelCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROWEXACT}), col, set, lpexact, row) end -function SCIPincludeHeurOfins(scip) - ccall((:SCIPincludeHeurOfins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactChgCoef(col, blkmem, set, eventqueue, lpexact, row, val) + ccall((:SCIPcolExactChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), col, blkmem, set, eventqueue, lpexact, row, val) end -function SCIPincludeHeurOneopt(scip) - ccall((:SCIPincludeHeurOneopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactIncCoef(col, blkmem, set, eventqueue, lpexact, row, incval) + ccall((:SCIPcolExactIncCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), col, blkmem, set, eventqueue, lpexact, row, incval) end -function SCIPincludeHeurPADM(scip) - ccall((:SCIPincludeHeurPADM, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactChgObj(col, set, lpexact, newobj) + ccall((:SCIPcolExactChgObj, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), col, set, lpexact, newobj) end -function SCIPincludeHeurPscostdiving(scip) - ccall( - (:SCIPincludeHeurPscostdiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPcolExactChgLb(col, set, lpexact, newlb) + ccall((:SCIPcolExactChgLb, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), col, set, lpexact, newlb) end -function SCIPincludeHeurProximity(scip) - ccall( - (:SCIPincludeHeurProximity, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPapplyProximity( - scip, - heur, - result, - minimprove, - nnodes, - nlpiters, - nusednodes, - nusedlpiters, - freesubscip, -) - ccall( - (:SCIPapplyProximity, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_HEUR}, - Ptr{SCIP_RESULT}, - Cdouble, - Clonglong, - Clonglong, - Ptr{Clonglong}, - Ptr{Clonglong}, - Cuint, - ), - scip, - heur, - result, - minimprove, - nnodes, - nlpiters, - nusednodes, - nusedlpiters, - freesubscip, - ) +function SCIPcolExactChgUb(col, set, lpexact, newub) + ccall((:SCIPcolExactChgUb, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), col, set, lpexact, newub) end -function SCIPdeleteSubproblemProximity(scip) - ccall( - (:SCIPdeleteSubproblemProximity, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactCapture(row) + ccall((:SCIProwExactCapture, libscip), Cvoid, (Ptr{SCIP_ROWEXACT},), row) end -function SCIPincludeHeurRandrounding(scip) - ccall( - (:SCIPincludeHeurRandrounding, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactPrint(row, messagehdlr, file) + ccall((:SCIProwExactPrint, libscip), Cvoid, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), row, messagehdlr, file) end -function SCIPincludeHeurRens(scip) - ccall((:SCIPincludeHeurRens, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwExactGetIndex(row) + ccall((:SCIProwExactGetIndex, libscip), Cint, (Ptr{SCIP_ROWEXACT},), row) end -function SCIPapplyRens( - scip, - heur, - result, - minfixingrate, - minimprove, - maxnodes, - nstallnodes, - startsol, - binarybounds, - uselprows, -) - ccall( - (:SCIPapplyRens, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_HEUR}, - Ptr{SCIP_RESULT}, - Cdouble, - Cdouble, - Clonglong, - Clonglong, - Cchar, - Cuint, - Cuint, - ), - scip, - heur, - result, - minfixingrate, - minimprove, - maxnodes, - nstallnodes, - startsol, - binarybounds, - uselprows, - ) +function SCIProwExactIsModifiable(row) + ccall((:SCIProwExactIsModifiable, libscip), Cuint, (Ptr{SCIP_ROWEXACT},), row) end -function SCIPincludeHeurReoptsols(scip) - ccall( - (:SCIPincludeHeurReoptsols, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwHasExRow(lpexact, row) + ccall((:SCIProwHasExRow, libscip), Cuint, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROW}), lpexact, row) end -function SCIPreoptsolsGetNCheckedsols(scip) - ccall((:SCIPreoptsolsGetNCheckedsols, libscip), Cint, (Ptr{SCIP},), scip) +function SCIProwExactChgLhs(rowexact, set, lpexact, lhs) + ccall((:SCIProwExactChgLhs, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), rowexact, set, lpexact, lhs) end -function SCIPreoptsolsGetNImprovingsols(scip) - ccall((:SCIPreoptsolsGetNImprovingsols, libscip), Cint, (Ptr{SCIP},), scip) +function SCIProwExactChgRhs(rowexact, set, lpexact, rhs) + ccall((:SCIProwExactChgRhs, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), rowexact, set, lpexact, rhs) end -function SCIPincludeHeurRepair(scip) - ccall((:SCIPincludeHeurRepair, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolGetColExact(col) + ccall((:SCIPcolGetColExact, libscip), Ptr{SCIP_COLEXACT}, (Ptr{SCIP_COL},), col) end -function SCIPincludeHeurRins(scip) - ccall((:SCIPincludeHeurRins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactCalcFarkasRedcostCoef(col, set, result, dual, usefarkas) + ccall((:SCIPcolExactCalcFarkasRedcostCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_RATIONAL}}, Cuint), col, set, result, dual, usefarkas) end -function SCIPincludeHeurRootsoldiving(scip) - ccall( - (:SCIPincludeHeurRootsoldiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactCreate(row, fprow, fprowrhs, blkmem, set, stat, lpexact, len, cols, vals, lhs, rhs, isfprelaxable) + ccall((:SCIProwExactCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}, Cint, Ptr{Ptr{SCIP_COLEXACT}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint), row, fprow, fprowrhs, blkmem, set, stat, lpexact, len, cols, vals, lhs, rhs, isfprelaxable) end -function SCIPincludeHeurRounding(scip) - ccall((:SCIPincludeHeurRounding, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwExactCreateFromRow(fprow, blkmem, set, stat, eventqueue, prob, lpexact) + ccall((:SCIProwExactCreateFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_PROB}, Ptr{SCIP_LPEXACT}), fprow, blkmem, set, stat, eventqueue, prob, lpexact) end -function SCIPincludeHeurShiftandpropagate(scip) - ccall( - (:SCIPincludeHeurShiftandpropagate, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactGenerateFpRows(blkmem, set, stat, eventqueue, lpexact, prob, row, rowlhs, rowrhs, onerowrelax, hasfprelax) + ccall((:SCIProwExactGenerateFpRows, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_PROB}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Ptr{Cuint}, Ptr{Cuint}), blkmem, set, stat, eventqueue, lpexact, prob, row, rowlhs, rowrhs, onerowrelax, hasfprelax) end -function SCIPincludeHeurShifting(scip) - ccall((:SCIPincludeHeurShifting, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactFlush(lpexact, blkmem, set, eventqueue) + ccall((:SCIPlpExactFlush, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}), lpexact, blkmem, set, eventqueue) end -function SCIPincludeHeurSimplerounding(scip) - ccall( - (:SCIPincludeHeurSimplerounding, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactLink(lpexact, blkmem, set, eventqueue) + ccall((:SCIPlpExactLink, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}), lpexact, blkmem, set, eventqueue) end -function SCIPincludeHeurSubNlp(scip) - ccall((:SCIPincludeHeurSubNlp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactBoundShiftUseful(lpexact) + ccall((:SCIPlpExactBoundShiftUseful, libscip), Cuint, (Ptr{SCIP_LPEXACT},), lpexact) end -function SCIPapplyHeurSubNlp(scip, heur, result, refpoint, resultsol) - ccall( - (:SCIPapplyHeurSubNlp, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_HEUR}, - Ptr{SCIP_RESULT}, - Ptr{SCIP_SOL}, - Ptr{SCIP_SOL}, - ), - scip, - heur, - result, - refpoint, - resultsol, - ) +function SCIPlpExactProjectShiftPossible(lpexact) + ccall((:SCIPlpExactProjectShiftPossible, libscip), Cuint, (Ptr{SCIP_LPEXACT},), lpexact) end -function SCIPupdateStartpointHeurSubNlp(scip, heur, solcand, violation) - ccall( - (:SCIPupdateStartpointHeurSubNlp, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}, Cdouble), - scip, - heur, - solcand, - violation, - ) +function SCIPlpExactIsSynced(lpexact, set, msg) + ccall((:SCIPlpExactIsSynced, libscip), Cuint, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), lpexact, set, msg) end -function SCIPgetStartCandidateHeurSubNlp(scip, heur) - ccall( - (:SCIPgetStartCandidateHeurSubNlp, libscip), - Ptr{SCIP_SOL}, - (Ptr{SCIP}, Ptr{SCIP_HEUR}), - scip, - heur, - ) +function SCIPlpExactCreate(lpexact, blkmem, fplp, set, messagehdlr, stat, name) + ccall((:SCIPlpExactCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LPEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{Cchar}), lpexact, blkmem, fplp, set, messagehdlr, stat, name) end -function SCIPincludeHeurTrivial(scip) - ccall((:SCIPincludeHeurTrivial, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactFree(lpexact, blkmem, set) + ccall((:SCIPlpExactFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LPEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), lpexact, blkmem, set) end -function SCIPincludeHeurTrivialnegation(scip) - ccall( - (:SCIPincludeHeurTrivialnegation, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactAddCol(lpexact, set, col) + ccall((:SCIPlpExactAddCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_COLEXACT}), lpexact, set, col) end -function SCIPincludeHeurTrustregion(scip) - ccall( - (:SCIPincludeHeurTrustregion, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactAddRow(lpexact, set, rowexact) + ccall((:SCIPlpExactAddRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_ROWEXACT}), lpexact, set, rowexact) end -function SCIPincludeHeurTrySol(scip) - ccall((:SCIPincludeHeurTrySol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwExactGetSolFeasibility(row, set, stat, sol, result) + ccall((:SCIProwExactGetSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), row, set, stat, sol, result) end -function SCIPheurPassSolTrySol(scip, heur, sol) - ccall( - (:SCIPheurPassSolTrySol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}), - scip, - heur, - sol, - ) +function SCIProwExactGetSolActivityWithErrorbound(rowexact, set, stat, sol, activity, errorbound) + ccall((:SCIProwExactGetSolActivityWithErrorbound, libscip), Cuint, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cdouble}), rowexact, set, stat, sol, activity, errorbound) end -function SCIPheurPassSolAddSol(scip, heur, sol) - ccall( - (:SCIPheurPassSolAddSol, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}), - scip, - heur, - sol, - ) +function SCIProwExactGetSolActivity(rowexact, set, stat, sol, useexact, result) + ccall((:SCIProwExactGetSolActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_RATIONAL}), rowexact, set, stat, sol, useexact, result) end -function SCIPincludeHeurTwoopt(scip) - ccall((:SCIPincludeHeurTwoopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwExactRelease(row, blkmem, set, lpexact) + ccall((:SCIProwExactRelease, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), row, blkmem, set, lpexact) end -function SCIPincludeHeurUndercover(scip) - ccall( - (:SCIPincludeHeurUndercover, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPcomputeCoverUndercover( - scip, - coversize, - cover, - timelimit, - memorylimit, - objlimit, - globalbounds, - onlyconvexify, - coverbd, - coveringobj, - success, -) - ccall( - (:SCIPcomputeCoverUndercover, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cint}, - Ptr{Ptr{SCIP_VAR}}, - Cdouble, - Cdouble, - Cdouble, - Cuint, - Cuint, - Cuint, - Cchar, - Ptr{Cuint}, - ), - scip, - coversize, - cover, - timelimit, - memorylimit, - objlimit, - globalbounds, - onlyconvexify, - coverbd, - coveringobj, - success, - ) +function SCIProwExactFree(row, blkmem, set, lpexact) + ccall((:SCIProwExactFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), row, blkmem, set, lpexact) end -function SCIPincludeHeurVbounds(scip) - ccall((:SCIPincludeHeurVbounds, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwExactEnsureSize(row, blkmem, set, num) + ccall((:SCIProwExactEnsureSize, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), row, blkmem, set, num) end -function SCIPincludeHeurVeclendiving(scip) - ccall( - (:SCIPincludeHeurVeclendiving, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactAddConstant(row, set, stat, lpexact, addval) + ccall((:SCIProwExactAddConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), row, set, stat, lpexact, addval) end -function SCIPincludeHeurZeroobj(scip) - ccall((:SCIPincludeHeurZeroobj, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwExactAddCoef(rowexact, blkmem, set, eventqueue, lpexact, colexact, val) + ccall((:SCIProwExactAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_COLEXACT}, Ptr{SCIP_RATIONAL}), rowexact, blkmem, set, eventqueue, lpexact, colexact, val) end -function SCIPapplyZeroobj(scip, heur, result, minimprove, nnodes) - ccall( - (:SCIPapplyZeroobj, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cdouble, Clonglong), - scip, - heur, - result, - minimprove, - nnodes, - ) +function SCIProwExactDelCoef(row, set, lpexact, col) + ccall((:SCIProwExactDelCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_COLEXACT}), row, set, lpexact, col) end -function SCIPincludeHeurZirounding(scip) - ccall( - (:SCIPincludeHeurZirounding, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactChgCoef(row, blkmem, set, eventqueue, lpexact, col, val) + ccall((:SCIProwExactChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_COLEXACT}, Ptr{SCIP_RATIONAL}), row, blkmem, set, eventqueue, lpexact, col, val) end -function SCIPincludeNlhdlrBilinear(scip) - ccall( - (:SCIPincludeNlhdlrBilinear, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPgetNlhdlrBilinearExprs(nlhdlr) - ccall( - (:SCIPgetNlhdlrBilinearExprs, libscip), - Ptr{Ptr{SCIP_EXPR}}, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) -end - -function SCIPgetNlhdlrBilinearExprsdata(nlhdlr) - ccall( - (:SCIPgetNlhdlrBilinearExprsdata, libscip), - Ptr{Ptr{SCIP_NLHDLREXPRDATA}}, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) -end - -function SCIPgetNlhdlrBilinearNExprs(nlhdlr) - ccall( - (:SCIPgetNlhdlrBilinearNExprs, libscip), - Cint, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) -end - -function SCIPaddNlhdlrBilinearIneq( - scip, - nlhdlr, - expr, - xcoef, - ycoef, - constant, - success, -) - ccall( - (:SCIPaddNlhdlrBilinearIneq, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_NLHDLR}, - Ptr{SCIP_EXPR}, - Cdouble, - Cdouble, - Cdouble, - Ptr{Cuint}, - ), - scip, - nlhdlr, - expr, - xcoef, - ycoef, - constant, - 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{Cuint}, - ), - 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, - Cuint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - ), - 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, - Cuint, - Cdouble, - Cdouble, - Cdouble, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - ), - 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, - Cuint, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - ), - scip, - bilincoef, - lbx, - ubx, - refpointx, - lby, - uby, - refpointy, - overestimate, - alpha1, - beta1, - gamma1, - alpha2, - beta2, - gamma2, - lincoefx, - lincoefy, - linconstant, - success, - ) +function SCIProwExactIncCoef(row, blkmem, set, eventqueue, lpexact, col, incval) + ccall((:SCIProwExactIncCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_COLEXACT}, Ptr{SCIP_RATIONAL}), row, blkmem, set, eventqueue, lpexact, col, incval) end -function SCIPincludeNlhdlrConvex(scip) - ccall((:SCIPincludeNlhdlrConvex, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwExactChgConstant(row, stat, lpexact, constant) + ccall((:SCIProwExactChgConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), row, stat, lpexact, constant) end -function SCIPincludeNlhdlrConcave(scip) - ccall( - (:SCIPincludeNlhdlrConcave, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactGetLPFeasibility(row, set, stat, lpexact, result) + ccall((:SCIProwExactGetLPFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), row, set, stat, lpexact, result) end -function SCIPhasExprCurvature(scip, expr, curv, success, assumevarfixed) - ccall( - (:SCIPhasExprCurvature, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_EXPR}, - SCIP_EXPRCURV, - Ptr{Cuint}, - Ptr{SCIP_HASHMAP}, - ), - scip, - expr, - curv, - success, - assumevarfixed, - ) +function SCIProwExactGetPseudoFeasibility(row, set, stat, result) + ccall((:SCIProwExactGetPseudoFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_RATIONAL}), row, set, stat, result) end -function SCIPincludeNlhdlrDefault(scip) - ccall( - (:SCIPincludeNlhdlrDefault, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactGetLPActivity(row, stat, lpexact) + ccall((:SCIProwExactGetLPActivity, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}), row, stat, lpexact) end -function SCIPincludeNlhdlrPerspective(scip) - ccall( - (:SCIPincludeNlhdlrPerspective, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactGetPseudoActivity(row, stat) + ccall((:SCIProwExactGetPseudoActivity, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), row, stat) end -function SCIPincludeNlhdlrQuadratic(scip) - ccall( - (:SCIPincludeNlhdlrQuadratic, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactDelaySort(rowexact) + ccall((:SCIProwExactDelaySort, libscip), Cvoid, (Ptr{SCIP_ROWEXACT},), rowexact) end -function SCIPincludeNlhdlrQuotient(scip) - ccall( - (:SCIPincludeNlhdlrQuotient, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIProwExactForceSort(rowexact, set) + ccall((:SCIProwExactForceSort, libscip), Cvoid, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}), rowexact, set) end -function SCIPincludeNlhdlrSoc(scip) - ccall((:SCIPincludeNlhdlrSoc, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIProwExactRecalcLPActivity(rowexact, stat) + ccall((:SCIProwExactRecalcLPActivity, libscip), Cvoid, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), rowexact, stat) end -function SCIPisSOCNonlinear( - scip, - cons, - compeigenvalues, - success, - sidetype, - vars, - offsets, - transcoefs, - transcoefsidx, - termbegins, - nvars, - nterms, -) - ccall( - (:SCIPisSOCNonlinear, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_CONS}, - Cuint, - Ptr{Cuint}, - Ptr{SCIP_SIDETYPE}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cint}}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - cons, - compeigenvalues, - success, - sidetype, - vars, - offsets, - transcoefs, - transcoefsidx, - termbegins, - nvars, - nterms, - ) -end - -function SCIPfreeSOCArraysNonlinear( - scip, - vars, - offsets, - transcoefs, - transcoefsidx, - termbegins, - nvars, - nterms, -) - ccall( - (:SCIPfreeSOCArraysNonlinear, libscip), - Cvoid, - ( - Ptr{SCIP}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cint}}, - Cint, - Cint, - ), - scip, - vars, - offsets, - transcoefs, - transcoefsidx, - termbegins, - nvars, - nterms, - ) +function SCIProwExactRecalcPseudoActivity(rowexact, stat) + ccall((:SCIProwExactRecalcPseudoActivity, libscip), Cvoid, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), rowexact, stat) end -function SCIPincludeNodeselBfs(scip) - ccall((:SCIPincludeNodeselBfs, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactGetObj(col) + ccall((:SCIPcolExactGetObj, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) end -function SCIPincludeNodeselBreadthfirst(scip) - ccall( - (:SCIPincludeNodeselBreadthfirst, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPcolExactGetLb(col) + ccall((:SCIPcolExactGetLb, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) end -function SCIPincludeNodeselDfs(scip) - ccall((:SCIPincludeNodeselDfs, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcolExactGetUb(col) + ccall((:SCIPcolExactGetUb, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) end -function SCIPincludeNodeselEstimate(scip) - ccall( - (:SCIPincludeNodeselEstimate, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPcolExactGetBestBound(col) + ccall((:SCIPcolExactGetBestBound, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) end -function SCIPincludeNodeselHybridestim(scip) - ccall( - (:SCIPincludeNodeselHybridestim, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPcolExactGetPrimsol(col) + ccall((:SCIPcolExactGetPrimsol, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) end -function SCIPincludeNodeselUct(scip) - ccall((:SCIPincludeNodeselUct, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactUpdateVarObj(set, lpexact, var, oldobj, newobj) + ccall((:SCIPlpExactUpdateVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), set, lpexact, var, oldobj, newobj) end -function SCIPincludeNodeselRestartdfs(scip) - ccall( - (:SCIPincludeNodeselRestartdfs, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactUpdateVarLbGlobal(lpexact, set, var, oldlb, newlb) + ccall((:SCIPlpExactUpdateVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), lpexact, set, var, oldlb, newlb) end -function SCIPincludePresolBoundshift(scip) - ccall( - (:SCIPincludePresolBoundshift, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactUpdateVarLb(lpexact, set, var, oldlb, newlb) + ccall((:SCIPlpExactUpdateVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), lpexact, set, var, oldlb, newlb) end -function SCIPincludePresolConvertinttobin(scip) - ccall( - (:SCIPincludePresolConvertinttobin, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactUpdateVarUbGlobal(lpexact, set, var, oldub, newub) + ccall((:SCIPlpExactUpdateVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), lpexact, set, var, oldub, newub) end -function SCIPincludePresolDomcol(scip) - ccall((:SCIPincludePresolDomcol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactUpdateVarUb(lpexact, set, var, oldub, newub) + ccall((:SCIPlpExactUpdateVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), lpexact, set, var, oldub, newub) end -function SCIPincludePresolDualagg(scip) - ccall( - (:SCIPincludePresolDualagg, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactUpdateAddVar(lpexact, set, var) + ccall((:SCIPlpExactUpdateAddVar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lpexact, set, var) end -function SCIPincludePresolDualcomp(scip) - ccall( - (:SCIPincludePresolDualcomp, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactUpdateDelVar(lpexact, set, var) + ccall((:SCIPlpExactUpdateDelVar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lpexact, set, var) end -function SCIPincludePresolDualinfer(scip) - ccall( - (:SCIPincludePresolDualinfer, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactUpdateVarColumn(lpexact, set, var) + ccall((:SCIPlpExactUpdateVarColumn, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lpexact, set, var) end -function SCIPincludePresolGateextraction(scip) - ccall( - (:SCIPincludePresolGateextraction, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactUpdateVarLoose(lpexact, set, var) + ccall((:SCIPlpExactUpdateVarLoose, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lpexact, set, var) end -function SCIPincludePresolImplics(scip) - ccall( - (:SCIPincludePresolImplics, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactDecNLoosevars(lpexact) + ccall((:SCIPlpExactDecNLoosevars, libscip), Cvoid, (Ptr{SCIP_LPEXACT},), lpexact) end -function SCIPincludePresolInttobinary(scip) - ccall( - (:SCIPincludePresolInttobinary, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactGetNRows(lpexact) + ccall((:SCIPlpExactGetNRows, libscip), Cint, (Ptr{SCIP_LPEXACT},), lpexact) end -function SCIPincludePresolRedvub(scip) - ccall((:SCIPincludePresolRedvub, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactGetSol(lpexact, set, stat, primalfeasible, dualfeasible, overwritefplp) + ccall((:SCIPlpExactGetSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}, Cuint), lpexact, set, stat, primalfeasible, dualfeasible, overwritefplp) end -function SCIPincludePresolQPKKTref(scip) - ccall( - (:SCIPincludePresolQPKKTref, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactGetUnboundedSol(lpexact, set, stat, primalfeasible, rayfeasible) + ccall((:SCIPlpExactGetUnboundedSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}), lpexact, set, stat, primalfeasible, rayfeasible) end -function SCIPincludePresolTrivial(scip) - ccall( - (:SCIPincludePresolTrivial, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactGetPrimalRay(lpexact, set, ray) + ccall((:SCIPlpExactGetPrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{Ptr{SCIP_RATIONAL}}), lpexact, set, ray) end -function SCIPincludePresolTworowbnd(scip) - ccall( - (:SCIPincludePresolTworowbnd, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactGetDualfarkas(lpexact, set, stat, valid, overwritefplp) + ccall((:SCIPlpExactGetDualfarkas, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Cuint), lpexact, set, stat, valid, overwritefplp) end -function SCIPincludePresolSparsify(scip) - ccall( - (:SCIPincludePresolSparsify, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactGetIterations(lpexact, iterations) + ccall((:SCIPlpExactGetIterations, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{Cint}), lpexact, iterations) end -function SCIPincludePresolDualsparsify(scip) - ccall( - (:SCIPincludePresolDualsparsify, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactGetObjval(lpexact, set, res) + ccall((:SCIPlpExactGetObjval, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}), lpexact, set, res) end -function SCIPincludePresolStuffing(scip) - ccall( - (:SCIPincludePresolStuffing, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactGetPseudoObjval(lpexact, set, res) + ccall((:SCIPlpExactGetPseudoObjval, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}), lpexact, set, res) end -function SCIPincludePropDualfix(scip) - ccall((:SCIPincludePropDualfix, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactShrinkCols(lpexact, set, newncols) + ccall((:SCIPlpExactShrinkCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cint), lpexact, set, newncols) end -function SCIPgenVBoundAdd( - scip, - genvboundprop, - vars, - var, - coefs, - ncoefs, - coefprimalbound, - constant, - boundtype, -) - ccall( - (:SCIPgenVBoundAdd, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_PROP}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{SCIP_VAR}, - Ptr{Cdouble}, - Cint, - Cdouble, - Cdouble, - SCIP_BOUNDTYPE, - ), - scip, - genvboundprop, - vars, - var, - coefs, - ncoefs, - coefprimalbound, - constant, - boundtype, - ) +function SCIPlpExactShrinkRows(lpexact, blkmem, set, newnrows) + ccall((:SCIPlpExactShrinkRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), lpexact, blkmem, set, newnrows) end -function SCIPincludePropGenvbounds(scip) - ccall( - (:SCIPincludePropGenvbounds, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactDelRowset(lpexact, blkmem, set, rowdstat) + ccall((:SCIPlpExactDelRowset, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{Cint}), lpexact, blkmem, set, rowdstat) end -function SCIPincludePropNlobbt(scip) - ccall((:SCIPincludePropNlobbt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactReset(lpexact, blkmem, set, stat, eventqueue) + ccall((:SCIPlpExactReset, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}), lpexact, blkmem, set, stat, eventqueue) end -function SCIPincludePropObbt(scip) - ccall((:SCIPincludePropObbt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactClear(lpexact, blkmem, set) + ccall((:SCIPlpExactClear, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), lpexact, blkmem, set) end -function SCIPincludePropProbing(scip) - ccall((:SCIPincludePropProbing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactForceExactSolve(lpexact, set) + ccall((:SCIPlpExactForceExactSolve, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}), lpexact, set) end -function SCIPapplyProbingVar( - scip, - vars, - nvars, - probingpos, - boundtype, - bound, - maxproprounds, - impllbs, - implubs, - proplbs, - propubs, - cutoff, -) - ccall( - (:SCIPapplyProbingVar, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cint, - SCIP_BOUNDTYPE, - Cdouble, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - ), - scip, - vars, - nvars, - probingpos, - boundtype, - bound, - maxproprounds, - impllbs, - implubs, - proplbs, - propubs, - cutoff, - ) -end - -function SCIPanalyzeDeductionsProbing( - scip, - probingvar, - leftub, - rightlb, - nvars, - vars, - leftimpllbs, - leftimplubs, - leftproplbs, - leftpropubs, - rightimpllbs, - rightimplubs, - rightproplbs, - rightpropubs, - nfixedvars, - naggrvars, - nimplications, - nchgbds, - cutoff, -) - ccall( - (:SCIPanalyzeDeductionsProbing, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cuint}, - ), - scip, - probingvar, - leftub, - rightlb, - nvars, - vars, - leftimpllbs, - leftimplubs, - leftproplbs, - leftpropubs, - rightimpllbs, - rightimplubs, - rightproplbs, - rightpropubs, - nfixedvars, - naggrvars, - nimplications, - nchgbds, - cutoff, - ) +function SCIPlpExactForceSafeBound(lpexact, set) + ccall((:SCIPlpExactForceSafeBound, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}), lpexact, set) end -function SCIPincludePropPseudoobj(scip) - ccall( - (:SCIPincludePropPseudoobj, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) -end - -function SCIPpropagateCutoffboundVar( - scip, - prop, - var, - cutoffbound, - pseudoobjval, - tightened, -) - ccall( - (:SCIPpropagateCutoffboundVar, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_PROP}, - Ptr{SCIP_VAR}, - Cdouble, - Cdouble, - Ptr{Cuint}, - ), - scip, - prop, - var, - cutoffbound, - pseudoobjval, - tightened, - ) +function SCIPlpExactAllowExactSolve(lpexact, set, allowexact) + ccall((:SCIPlpExactAllowExactSolve, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cuint), lpexact, set, allowexact) end -function SCIPincludePropRedcost(scip) - ccall((:SCIPincludePropRedcost, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactGetSolstat(lpexact) + ccall((:SCIPlpExactGetSolstat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP_LPEXACT},), lpexact) end -function SCIPincludePropRootredcost(scip) - ccall( - (:SCIPincludePropRootredcost, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPlpExactSetCutoffbound(lpexact, set, cutoffbound) + ccall((:SCIPlpExactSetCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cdouble), lpexact, set, cutoffbound) end -function SCIPincludePropSymmetry(scip) - ccall((:SCIPincludePropSymmetry, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactSolveAndEval(lpexact, lp, set, messagehdlr, blkmem, stat, eventqueue, prob, itlim, lperror, usefarkas) + ccall((:SCIPlpExactSolveAndEval, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_PROB}, Clonglong, Ptr{Cuint}, Cuint), lpexact, lp, set, messagehdlr, blkmem, stat, eventqueue, prob, itlim, lperror, usefarkas) end -function SCIPgetSymmetry( - scip, - npermvars, - permvars, - permvarmap, - nperms, - perms, - permstrans, - log10groupsize, - binvaraffected, - components, - componentbegins, - vartocomponent, - ncomponents, -) - ccall( - (:SCIPgetSymmetry, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Cint}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Ptr{SCIP_HASHMAP}}, - Ptr{Cint}, - Ptr{Ptr{Ptr{Cint}}}, - Ptr{Ptr{Ptr{Cint}}}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cint}}, - Ptr{Cint}, - ), - scip, - npermvars, - permvars, - permvarmap, - nperms, - perms, - permstrans, - log10groupsize, - binvaraffected, - components, - componentbegins, - vartocomponent, - ncomponents, - ) -end - -function SCIPisOrbitalfixingEnabled(scip) - ccall((:SCIPisOrbitalfixingEnabled, libscip), Cuint, (Ptr{SCIP},), scip) +function SCIPlpExactGetState(lpexact, blkmem, lpistate) + ccall((:SCIPlpExactGetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lpexact, blkmem, lpistate) end -function SCIPgetSymmetryNGenerators(scip) - ccall((:SCIPgetSymmetryNGenerators, libscip), Cint, (Ptr{SCIP},), scip) +function SCIPlpExactSetState(lpexact, blkmem, set, eventqueue, lpistate, wasprimfeas, wasprimchecked, wasdualfeas, wasdualchecked) + ccall((:SCIPlpExactSetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPISTATE}, Cuint, Cuint, Cuint, Cuint), lpexact, blkmem, set, eventqueue, lpistate, wasprimfeas, wasprimchecked, wasdualfeas, wasdualchecked) end -function SCIPincludePropVbounds(scip) - ccall((:SCIPincludePropVbounds, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactFreeState(lpexact, blkmem, lpistate) + ccall((:SCIPlpExactFreeState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lpexact, blkmem, lpistate) end -function SCIPisPropagatedVbounds(scip) - ccall((:SCIPisPropagatedVbounds, libscip), Cuint, (Ptr{SCIP},), scip) +function SCIPlpExactStartDive(lpexact, blkmem, set, stat) + ccall((:SCIPlpExactStartDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), lpexact, blkmem, set, stat) end -function SCIPexecPropVbounds(scip, force, result) - ccall( - (:SCIPexecPropVbounds, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint, Ptr{SCIP_RESULT}), - scip, - force, - result, - ) +function SCIPlpExactEndDive(lpexact, blkmem, set, stat, eventqueue, vars, nvars) + ccall((:SCIPlpExactEndDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{Ptr{SCIP_VAR}}, Cint), lpexact, blkmem, set, stat, eventqueue, vars, nvars) end -function SCIPincludeReaderBnd(scip) - ccall((:SCIPincludeReaderBnd, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactWrite(lpexact, fname) + ccall((:SCIPlpExactWrite, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{Cchar}), lpexact, fname) end -function SCIPincludeReaderCcg(scip) - ccall((:SCIPincludeReaderCcg, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactOverwriteFpDualSol(lpexact, dualfarkas) + ccall((:SCIPlpExactOverwriteFpDualSol, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Cuint), lpexact, dualfarkas) end -function SCIPwriteCcg( - scip, - file, - name, - transformed, - vars, - nvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwriteCcg, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Cuint, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - transformed, - vars, - nvars, - conss, - nconss, - result, - ) +function SCIPlpExactSyncLPs(lpexact, blkmem, set) + ccall((:SCIPlpExactSyncLPs, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), lpexact, blkmem, set) end -function SCIPincludeReaderCip(scip) - ccall((:SCIPincludeReaderCip, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcreateEmptyRowConsExact(scip, rowexact, fprow, fprowrhs, lhs, rhs, isfprelaxable) + ccall((:SCIPcreateEmptyRowConsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint), scip, rowexact, fprow, fprowrhs, lhs, rhs, isfprelaxable) end -function SCIPincludeReaderCnf(scip) - ccall((:SCIPincludeReaderCnf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcreateRowExact(scip, row, fprow, len, cols, vals, lhs, rhs, isfprelaxable) + ccall((:SCIPcreateRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_COLEXACT}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint), scip, row, fprow, len, cols, vals, lhs, rhs, isfprelaxable) end -function SCIPincludeReaderCor(scip) - ccall((:SCIPincludeReaderCor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPcreateRowExactFromRow(scip, fprow) + ccall((:SCIPcreateRowExactFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, fprow) end -function SCIPreadCor(scip, filename, result) - ccall( - (:SCIPreadCor, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), - scip, - filename, - result, - ) +function SCIPgenerateFpRowsFromRowExact(scip, row, rowlhs, rowrhs, onerowrelax, hasfprelax) + ccall((:SCIPgenerateFpRowsFromRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Ptr{Cuint}, Ptr{Cuint}), scip, row, rowlhs, rowrhs, onerowrelax, hasfprelax) end -function SCIPcorHasRead(reader) - ccall((:SCIPcorHasRead, libscip), Cuint, (Ptr{SCIP_READER},), reader) +function SCIPcaptureRowExact(scip, row) + ccall((:SCIPcaptureRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}), scip, row) end -function SCIPcorGetNVarNames(reader) - ccall((:SCIPcorGetNVarNames, libscip), Cint, (Ptr{SCIP_READER},), reader) +function SCIPreleaseRowExact(scip, row) + ccall((:SCIPreleaseRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWEXACT}}), scip, row) end -function SCIPcorGetNConsNames(reader) - ccall((:SCIPcorGetNConsNames, libscip), Cint, (Ptr{SCIP_READER},), reader) +function SCIPchgRowExactLhs(scip, row, lhs) + ccall((:SCIPchgRowExactLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), scip, row, lhs) end -function SCIPcorGetVarName(reader, i) - ccall( - (:SCIPcorGetVarName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_READER}, Cint), - reader, - i, - ) +function SCIPchgRowExactRhs(scip, row, rhs) + ccall((:SCIPchgRowExactRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), scip, row, rhs) end -function SCIPcorGetConsName(reader, i) - ccall( - (:SCIPcorGetConsName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_READER}, Cint), - reader, - i, - ) +function SCIPaddVarsToRowExact(scip, row, nvars, vars, vals) + ccall((:SCIPaddVarsToRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}), scip, row, nvars, vars, vals) end -function SCIPincludeReaderDec(scip) - ccall((:SCIPincludeReaderDec, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPgetRowSolActivityWithErrorboundExact(scip, row, sol, activity, errorbound) + ccall((:SCIPgetRowSolActivityWithErrorboundExact, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cdouble}), scip, row, sol, activity, errorbound) end -function SCIPincludeReaderDiff(scip) - ccall((:SCIPincludeReaderDiff, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPgetRowSolActivityExact(scip, row, sol, useexact, result) + ccall((:SCIPgetRowSolActivityExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_RATIONAL}), scip, row, sol, useexact, result) end -function SCIPreadDiff(scip, reader, filename, result) - ccall( - (:SCIPreadDiff, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), - scip, - reader, - filename, - result, - ) -end - -function SCIPwriteDiff( - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwriteDiff, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Cuint, - SCIP_OBJSENSE, - Cdouble, - Cdouble, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cint, - Cint, - Cint, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, - ) +function SCIPgetRowSolFeasibilityExact(scip, row, sol, result) + ccall((:SCIPgetRowSolFeasibilityExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, row, sol, result) end -function SCIPincludeReaderFix(scip) - ccall((:SCIPincludeReaderFix, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPprintRowExact(scip, row, file) + ccall((:SCIPprintRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{Libc.FILE}), scip, row, file) end -function SCIPincludeReaderFzn(scip) - ccall((:SCIPincludeReaderFzn, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPlpExactIsSolved(scip) + ccall((:SCIPlpExactIsSolved, libscip), Cuint, (Ptr{SCIP},), scip) end -function SCIPprintSolReaderFzn(scip, sol, file) - ccall( - (:SCIPprintSolReaderFzn, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), - scip, - sol, - file, - ) +function SCIPgetLPExactSolstat(scip) + ccall((:SCIPgetLPExactSolstat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP},), scip) end -function SCIPincludeReaderGms(scip) - ccall((:SCIPincludeReaderGms, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPgetLPExactObjval(scip, result) + ccall((:SCIPgetLPExactObjval, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) end -function SCIPwriteGms( - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwriteGms, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Cuint, - SCIP_OBJSENSE, - Cdouble, - Cdouble, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cint, - Cint, - Cint, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, - ) +function SCIPchgVarLbExactDive(scip, var, newbound) + ccall((:SCIPchgVarLbExactDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) end -function SCIPincludeReaderLp(scip) - ccall((:SCIPincludeReaderLp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPchgVarUbExactDive(scip, var, newbound) + ccall((:SCIPchgVarUbExactDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) end -function SCIPreadLp(scip, reader, filename, result) - ccall( - (:SCIPreadLp, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), - scip, - reader, - filename, - result, - ) -end - -function SCIPwriteLp( - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwriteLp, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Cuint, - SCIP_OBJSENSE, - Cdouble, - Cdouble, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cint, - Cint, - Cint, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, - ) +function SCIPsolveExactDiveLP(scip, itlim, lperror, cutoff) + ccall((:SCIPsolveExactDiveLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, itlim, lperror, cutoff) end -function SCIPincludeReaderMps(scip) - ccall((:SCIPincludeReaderMps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPstartExactDive(scip) + ccall((:SCIPstartExactDive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPreadMps( - scip, - reader, - filename, - result, - varnames, - consnames, - varnamessize, - consnamessize, - nvarnames, - nconsnames, -) - ccall( - (:SCIPreadMps, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_READER}, - Ptr{Cchar}, - Ptr{SCIP_RESULT}, - Ptr{Ptr{Ptr{Cchar}}}, - Ptr{Ptr{Ptr{Cchar}}}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - reader, - filename, - result, - varnames, - consnames, - varnamessize, - consnamessize, - nvarnames, - nconsnames, - ) -end - -function SCIPwriteMps( - scip, - reader, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - fixedvars, - nfixedvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwriteMps, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_READER}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Cuint, - SCIP_OBJSENSE, - Cdouble, - Cdouble, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cint, - Cint, - Cint, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - reader, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - fixedvars, - nfixedvars, - conss, - nconss, - result, - ) +function SCIPisExactDivePossible(scip) + ccall((:SCIPisExactDivePossible, libscip), Cuint, (Ptr{SCIP},), scip) end -function SCIPincludeReaderMst(scip) - ccall((:SCIPincludeReaderMst, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPinExactDive(scip) + ccall((:SCIPinExactDive, libscip), Cuint, (Ptr{SCIP},), scip) end -function SCIPincludeReaderNl(scip) - ccall((:SCIPincludeReaderNl, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPendExactDive(scip) + ccall((:SCIPendExactDive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPwriteSolutionNl(scip) - ccall((:SCIPwriteSolutionNl, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPwriteLPexact(scip, filename) + ccall((:SCIPwriteLPexact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) end -function SCIPincludeReaderOpb(scip) - ccall((:SCIPincludeReaderOpb, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetCopyPlugins(sourceset, targetset, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copyiisfinders, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, allvalid) + ccall((:SCIPsetCopyPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_SET}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourceset, targetset, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copyiisfinders, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, allvalid) end -function SCIPreadOpb(scip, reader, filename, result) - ccall( - (:SCIPreadOpb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), - scip, - reader, - filename, - result, - ) -end - -function SCIPwriteOpb( - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - fixedvars, - nfixedvars, - conss, - nconss, - genericnames, - result, -) - ccall( - (:SCIPwriteOpb, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Cuint, - SCIP_OBJSENSE, - Cdouble, - Cdouble, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cint, - Cint, - Cint, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Cuint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - fixedvars, - nfixedvars, - conss, - nconss, - genericnames, - result, - ) +function SCIPsetCopyParams(sourceset, targetset, messagehdlr) + ccall((:SCIPsetCopyParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), sourceset, targetset, messagehdlr) end -function SCIPincludeReaderOsil(scip) - ccall((:SCIPincludeReaderOsil, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetCreate(set, messagehdlr, blkmem, scip) + ccall((:SCIPsetCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SET}}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP}), set, messagehdlr, blkmem, scip) end -function SCIPincludeReaderPip(scip) - ccall((:SCIPincludeReaderPip, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetFree(set, blkmem) + ccall((:SCIPsetFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SET}}, Ptr{BMS_BLKMEM}), set, blkmem) end -function SCIPreadPip(scip, reader, filename, result) - ccall( - (:SCIPreadPip, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), - scip, - reader, - filename, - result, - ) -end - -function SCIPwritePip( - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwritePip, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Cuint, - SCIP_OBJSENSE, - Cdouble, - Cdouble, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cint, - Cint, - Cint, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, - ) +function SCIPsetGetStage(set) + ccall((:SCIPsetGetStage, libscip), SCIP_STAGE, (Ptr{SCIP_SET},), set) end -function SCIPincludeReaderPpm(scip) - ccall((:SCIPincludeReaderPpm, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetAddBoolParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) + ccall((:SCIPsetAddBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cuint}, Cuint, Cuint, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) end -function SCIPwritePpm( - scip, - file, - name, - readerdata, - transformed, - vars, - nvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwritePpm, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Ptr{SCIP_READERDATA}, - Cuint, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - readerdata, - transformed, - vars, - nvars, - conss, - nconss, - result, - ) +function SCIPsetAddIntParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) + ccall((:SCIPsetAddIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cint}, Cuint, Cint, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end -function SCIPincludeReaderPbm(scip) - ccall((:SCIPincludeReaderPbm, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetAddLongintParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) + ccall((:SCIPsetAddLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Clonglong}, Cuint, Clonglong, Clonglong, Clonglong, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end -function SCIPwritePbm( - scip, - file, - name, - readerdata, - transformed, - nvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwritePbm, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Ptr{SCIP_READERDATA}, - Cuint, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - readerdata, - transformed, - nvars, - conss, - nconss, - result, - ) +function SCIPsetAddRealParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) + ccall((:SCIPsetAddRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cdouble}, Cuint, Cdouble, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) end -function SCIPincludeReaderRlp(scip) - ccall((:SCIPincludeReaderRlp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetAddCharParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) + ccall((:SCIPsetAddCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Cchar, Ptr{Cchar}, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) end -function SCIPincludeReaderSmps(scip) - ccall((:SCIPincludeReaderSmps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetAddStringParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) + ccall((:SCIPsetAddStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Cuint, Ptr{Cchar}, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) end -function SCIPincludeReaderSol(scip) - ccall((:SCIPincludeReaderSol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetIsParamFixed(set, name) + ccall((:SCIPsetIsParamFixed, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPincludeReaderSto(scip) - ccall((:SCIPincludeReaderSto, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetGetParam(set, name) + ccall((:SCIPsetGetParam, libscip), Ptr{SCIP_PARAM}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPreadSto(scip, filename, result) - ccall( - (:SCIPreadSto, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), - scip, - filename, - result, - ) -end - -function SCIPwriteSto( - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, -) - ccall( - (:SCIPwriteSto, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Libc.FILE}, - Ptr{Cchar}, - Cuint, - SCIP_OBJSENSE, - Cdouble, - Cdouble, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cint, - Cint, - Cint, - Cint, - Ptr{Ptr{SCIP_CONS}}, - Cint, - Ptr{SCIP_RESULT}, - ), - scip, - file, - name, - transformed, - objsense, - objscale, - objoffset, - vars, - nvars, - nbinvars, - nintvars, - nimplvars, - ncontvars, - conss, - nconss, - result, - ) +function SCIPsetGetBoolParam(set, name, value) + ccall((:SCIPsetGetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cuint}), set, name, value) end -function SCIPstoGetNScenarios(scip) - ccall((:SCIPstoGetNScenarios, libscip), Cint, (Ptr{SCIP},), scip) +function SCIPsetGetIntParam(set, name, value) + ccall((:SCIPsetGetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cint}), set, name, value) end -function SCIPincludeReaderTim(scip) - ccall((:SCIPincludeReaderTim, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetGetLongintParam(set, name, value) + ccall((:SCIPsetGetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Clonglong}), set, name, value) end -function SCIPreadTim(scip, filename, result) - ccall( - (:SCIPreadTim, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), - scip, - filename, - result, - ) +function SCIPsetGetRealParam(set, name, value) + ccall((:SCIPsetGetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cdouble}), set, name, value) end -function SCIPtimHasRead(reader) - ccall((:SCIPtimHasRead, libscip), Cuint, (Ptr{SCIP_READER},), reader) +function SCIPsetGetCharParam(set, name, value) + ccall((:SCIPsetGetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cchar}), set, name, value) end -function SCIPtimGetNStages(scip) - ccall((:SCIPtimGetNStages, libscip), Cint, (Ptr{SCIP},), scip) +function SCIPsetGetStringParam(set, name, value) + ccall((:SCIPsetGetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), set, name, value) end -function SCIPtimGetStageName(scip, stagenum) - ccall( - (:SCIPtimGetStageName, libscip), - Ptr{Cchar}, - (Ptr{SCIP}, Cint), - scip, - stagenum, - ) +function SCIPsetChgParamFixed(set, name, fixed) + ccall((:SCIPsetChgParamFixed, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Cuint), set, name, fixed) end -function SCIPtimConsGetStageName(scip, consname) - ccall( - (:SCIPtimConsGetStageName, libscip), - Ptr{Cchar}, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - consname, - ) +function SCIPsetChgBoolParam(set, messagehdlr, param, value) + ccall((:SCIPsetChgBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cuint), set, messagehdlr, param, value) end -function SCIPtimFindStage(scip, stage) - ccall( - (:SCIPtimFindStage, libscip), - Cint, - (Ptr{SCIP}, Ptr{Cchar}), - scip, - stage, - ) +function SCIPsetSetBoolParam(set, messagehdlr, name, value) + ccall((:SCIPsetSetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cuint), set, messagehdlr, name, value) end -function SCIPtimGetStageVars(scip, stagenum) - ccall( - (:SCIPtimGetStageVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP}, Cint), - scip, - stagenum, - ) +function SCIPsetSetDefaultBoolParam(set, name, defaultvalue) + ccall((:SCIPsetSetDefaultBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Cuint), set, name, defaultvalue) end -function SCIPtimGetStageConss(scip, stagenum) - ccall( - (:SCIPtimGetStageConss, libscip), - Ptr{Ptr{SCIP_CONS}}, - (Ptr{SCIP}, Cint), - scip, - stagenum, - ) +function SCIPsetChgIntParam(set, messagehdlr, param, value) + ccall((:SCIPsetChgIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cint), set, messagehdlr, param, value) end -function SCIPtimGetStageNVars(scip, stagenum) - ccall( - (:SCIPtimGetStageNVars, libscip), - Cint, - (Ptr{SCIP}, Cint), - scip, - stagenum, - ) +function SCIPsetSetIntParam(set, messagehdlr, name, value) + ccall((:SCIPsetSetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cint), set, messagehdlr, name, value) end -function SCIPtimGetStageNConss(scip, stagenum) - ccall( - (:SCIPtimGetStageNConss, libscip), - Cint, - (Ptr{SCIP}, Cint), - scip, - stagenum, - ) +function SCIPsetSetDefaultIntParam(set, name, defaultvalue) + ccall((:SCIPsetSetDefaultIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Cint), set, name, defaultvalue) end -function SCIPincludeReaderWbo(scip) - ccall((:SCIPincludeReaderWbo, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetChgLongintParam(set, messagehdlr, param, value) + ccall((:SCIPsetChgLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Clonglong), set, messagehdlr, param, value) end -function SCIPincludeReaderZpl(scip) - ccall((:SCIPincludeReaderZpl, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSetLongintParam(set, messagehdlr, name, value) + ccall((:SCIPsetSetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Clonglong), set, messagehdlr, name, value) end -function SCIPincludeSepaEccuts(scip) - ccall((:SCIPincludeSepaEccuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetChgRealParam(set, messagehdlr, param, value) + ccall((:SCIPsetChgRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cdouble), set, messagehdlr, param, value) end -function SCIPincludeSepaCGMIP(scip) - ccall((:SCIPincludeSepaCGMIP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSetRealParam(set, messagehdlr, name, value) + ccall((:SCIPsetSetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cdouble), set, messagehdlr, name, value) end -function SCIPincludeSepaClique(scip) - ccall((:SCIPincludeSepaClique, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetChgCharParam(set, messagehdlr, param, value) + ccall((:SCIPsetChgCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cchar), set, messagehdlr, param, value) end -function SCIPincludeSepaClosecuts(scip) - ccall( - (:SCIPincludeSepaClosecuts, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetSetCharParam(set, messagehdlr, name, value) + ccall((:SCIPsetSetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cchar), set, messagehdlr, name, value) end -function SCIPsetBasePointClosecuts(scip, sol) - ccall( - (:SCIPsetBasePointClosecuts, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_SOL}), - scip, - sol, - ) +function SCIPsetChgStringParam(set, messagehdlr, param, value) + ccall((:SCIPsetChgStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Ptr{Cchar}), set, messagehdlr, param, value) end -function SCIPincludeSepaAggregation(scip) - ccall( - (:SCIPincludeSepaAggregation, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetSetStringParam(set, messagehdlr, name, value) + ccall((:SCIPsetSetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Ptr{Cchar}), set, messagehdlr, name, value) end -function SCIPincludeSepaConvexproj(scip) - ccall( - (:SCIPincludeSepaConvexproj, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetSetParam(set, messagehdlr, name, value) + ccall((:SCIPsetSetParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Ptr{Cchar}), set, messagehdlr, name, value) end -function SCIPincludeSepaDisjunctive(scip) - ccall( - (:SCIPincludeSepaDisjunctive, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetReadParams(set, messagehdlr, filename) + ccall((:SCIPsetReadParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}), set, messagehdlr, filename) end -function SCIPincludeSepaGauge(scip) - ccall((:SCIPincludeSepaGauge, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetWriteParams(set, messagehdlr, filename, comments, onlychanged) + ccall((:SCIPsetWriteParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cuint, Cuint), set, messagehdlr, filename, comments, onlychanged) end -function SCIPincludeSepaGomory(scip) - ccall((:SCIPincludeSepaGomory, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetResetParam(set, messagehdlr, name) + ccall((:SCIPsetResetParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}), set, messagehdlr, name) end -function SCIPincludeSepaImpliedbounds(scip) - ccall( - (:SCIPincludeSepaImpliedbounds, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetResetParams(set, messagehdlr) + ccall((:SCIPsetResetParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), set, messagehdlr) end -function SCIPincludeSepaInterminor(scip) - ccall( - (:SCIPincludeSepaInterminor, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetCheckParamValuePtrUnique(set) + ccall((:SCIPsetCheckParamValuePtrUnique, libscip), SCIP_RETCODE, (Ptr{SCIP_SET},), set) end -function SCIPincludeSepaIntobj(scip) - ccall((:SCIPincludeSepaIntobj, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSetEmphasis(set, messagehdlr, paramemphasis, quiet) + ccall((:SCIPsetSetEmphasis, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMEMPHASIS, Cuint), set, messagehdlr, paramemphasis, quiet) end -function SCIPincludeSepaMcf(scip) - ccall((:SCIPincludeSepaMcf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSetReoptimizationParams(set, messagehdlr) + ccall((:SCIPsetSetReoptimizationParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), set, messagehdlr) end -function SCIPincludeSepaMinor(scip) - ccall((:SCIPincludeSepaMinor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetEnableOrDisablePluginClocks(set, enabled) + ccall((:SCIPsetEnableOrDisablePluginClocks, libscip), Cvoid, (Ptr{SCIP_SET}, Cuint), set, enabled) end -function SCIPincludeSepaMixing(scip) - ccall((:SCIPincludeSepaMixing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSetSubscipsOff(set, messagehdlr, quiet) + ccall((:SCIPsetSetSubscipsOff, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Cuint), set, messagehdlr, quiet) end -function SCIPincludeSepaOddcycle(scip) - ccall((:SCIPincludeSepaOddcycle, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSetHeuristics(set, messagehdlr, paramsetting, quiet) + ccall((:SCIPsetSetHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), set, messagehdlr, paramsetting, quiet) end -function SCIPincludeSepaRapidlearning(scip) - ccall( - (:SCIPincludeSepaRapidlearning, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetSetPresolving(set, messagehdlr, paramsetting, quiet) + ccall((:SCIPsetSetPresolving, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), set, messagehdlr, paramsetting, quiet) end -function SCIPincludeSepaRlt(scip) - ccall((:SCIPincludeSepaRlt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSetSeparating(set, messagehdlr, paramsetting, quiet) + ccall((:SCIPsetSetSeparating, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), set, messagehdlr, paramsetting, quiet) end -function SCIPincludeSepaZerohalf(scip) - ccall((:SCIPincludeSepaZerohalf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetGetParams(set) + ccall((:SCIPsetGetParams, libscip), Ptr{Ptr{SCIP_PARAM}}, (Ptr{SCIP_SET},), set) end -function SCIPprocessShellArguments(scip, argc, argv, defaultsetname) - ccall( - (:SCIPprocessShellArguments, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}), - scip, - argc, - argv, - defaultsetname, - ) +function SCIPsetGetNParams(set) + ccall((:SCIPsetGetNParams, libscip), Cint, (Ptr{SCIP_SET},), set) end -function SCIPrunShell(argc, argv, defaultsetname) - ccall( - (:SCIPrunShell, libscip), - SCIP_RETCODE, - (Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}), - argc, - argv, - defaultsetname, - ) -end - -function SCIPcomputeOrbitsSym( - scip, - permvars, - npermvars, - perms, - nperms, - orbits, - orbitbegins, - norbits, -) - ccall( - (:SCIPcomputeOrbitsSym, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Ptr{Cint}}, - Cint, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - permvars, - npermvars, - perms, - nperms, - orbits, - orbitbegins, - norbits, - ) -end - -function SCIPcomputeOrbitsFilterSym( - scip, - npermvars, - permstrans, - nperms, - inactiveperms, - orbits, - orbitbegins, - norbits, - components, - componentbegins, - vartocomponent, - componentblocked, - ncomponents, - nmovedpermvars, -) - ccall( - (:SCIPcomputeOrbitsFilterSym, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Cint, - Ptr{Ptr{Cint}}, - Cint, - Ptr{UInt8}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cuint}, - Cint, - Cint, - ), - scip, - npermvars, - permstrans, - nperms, - inactiveperms, - orbits, - orbitbegins, - norbits, - components, - componentbegins, - vartocomponent, - componentblocked, - ncomponents, - nmovedpermvars, - ) -end - -function SCIPcomputeOrbitsComponentsSym( - scip, - npermvars, - permstrans, - nperms, - components, - componentbegins, - vartocomponent, - ncomponents, - orbits, - orbitbegins, - norbits, - varorbitmap, -) - ccall( - (:SCIPcomputeOrbitsComponentsSym, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Cint, - Ptr{Ptr{Cint}}, - Cint, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Cint, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - npermvars, - permstrans, - nperms, - components, - componentbegins, - vartocomponent, - ncomponents, - orbits, - orbitbegins, - norbits, - varorbitmap, - ) -end - -function SCIPcomputeOrbitVar( - scip, - npermvars, - perms, - permstrans, - components, - componentbegins, - ignoredvars, - varfound, - varidx, - component, - orbit, - orbitsize, -) - ccall( - (:SCIPcomputeOrbitVar, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Cint, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cint}}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{UInt8}, - Ptr{UInt8}, - Cint, - Cint, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - npermvars, - perms, - permstrans, - components, - componentbegins, - ignoredvars, - varfound, - varidx, - component, - orbit, - orbitsize, - ) -end - -function SCIPisInvolutionPerm( - perm, - vars, - nvars, - ntwocyclesperm, - nbincyclesperm, - earlytermination, -) - ccall( - (:SCIPisInvolutionPerm, libscip), - SCIP_RETCODE, - (Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}, Cuint), - perm, - vars, - nvars, - ntwocyclesperm, - nbincyclesperm, - earlytermination, - ) -end - -function SCIPdetermineNVarsAffectedSym( - scip, - perms, - nperms, - permvars, - npermvars, - nvarsaffected, -) - ccall( - (:SCIPdetermineNVarsAffectedSym, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{Cint}}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}), - scip, - perms, - nperms, - permvars, - npermvars, - nvarsaffected, - ) -end - -function SCIPcomputeComponentsSym( - scip, - perms, - nperms, - permvars, - npermvars, - transposed, - components, - componentbegins, - vartocomponent, - componentblocked, - ncomponents, -) - ccall( - (:SCIPcomputeComponentsSym, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{Cint}}, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Cuint, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{Cuint}}, - Ptr{Cint}, - ), - scip, - perms, - nperms, - permvars, - npermvars, - transposed, - components, - componentbegins, - vartocomponent, - componentblocked, - ncomponents, - ) -end - -function SCIPextendSubOrbitope( - suborbitope, - nrows, - nfilledcols, - coltoextend, - perm, - leftextension, - nusedelems, - permvars, - rowisbinary, - success, - infeasible, -) - ccall( - (:SCIPextendSubOrbitope, libscip), - SCIP_RETCODE, - ( - Ptr{Ptr{Cint}}, - Cint, - Cint, - Cint, - Ptr{Cint}, - Cuint, - Ptr{Ptr{Cint}}, - Ptr{Ptr{SCIP_VAR}}, - Ptr{UInt8}, - Ptr{Cuint}, - Ptr{Cuint}, - ), - suborbitope, - nrows, - nfilledcols, - coltoextend, - perm, - leftextension, - nusedelems, - permvars, - rowisbinary, - success, - infeasible, - ) -end - -function SCIPgenerateOrbitopeVarsMatrix( - scip, - vars, - nrows, - ncols, - permvars, - npermvars, - orbitopevaridx, - columnorder, - nusedelems, - rowisbinary, - infeasible, - storelexorder, - lexorder, - nvarsorder, - maxnvarsorder, -) - ccall( - (:SCIPgenerateOrbitopeVarsMatrix, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, - Cint, - Cint, - Ptr{Ptr{SCIP_VAR}}, - Cint, - Ptr{Ptr{Cint}}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{UInt8}, - Ptr{Cuint}, - Cuint, - Ptr{Ptr{Cint}}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - vars, - nrows, - ncols, - permvars, - npermvars, - orbitopevaridx, - columnorder, - nusedelems, - rowisbinary, - infeasible, - storelexorder, - lexorder, - nvarsorder, - maxnvarsorder, - ) -end - -function SCIPisPackingPartitioningOrbitope( - scip, - vars, - nrows, - ncols, - pprows, - npprows, - type, -) - ccall( - (:SCIPisPackingPartitioningOrbitope, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Cint, - Cint, - Ptr{Ptr{Cuint}}, - Ptr{Cint}, - Ptr{SCIP_ORBITOPETYPE}, - ), - scip, - vars, - nrows, - ncols, - pprows, - npprows, - type, - ) +function SCIPsetIncludeReader(set, reader) + ccall((:SCIPsetIncludeReader, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_READER}), set, reader) end -function SCIPincludeTableDefault(scip) - ccall((:SCIPincludeTableDefault, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetFindReader(set, name) + ccall((:SCIPsetFindReader, libscip), Ptr{SCIP_READER}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPincludeConcurrentScipSolvers(scip) - ccall( - (:SCIPincludeConcurrentScipSolvers, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetIncludePricer(set, pricer) + ccall((:SCIPsetIncludePricer, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_PRICER}), set, pricer) end -function SCIPincludeBendersDefault(scip) - ccall( - (:SCIPincludeBendersDefault, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetFindPricer(set, name) + ccall((:SCIPsetFindPricer, libscip), Ptr{SCIP_PRICER}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPcreateBendersDefault(scip, subproblems, nsubproblems) - ccall( - (:SCIPcreateBendersDefault, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP}}, Cint), - scip, - subproblems, - nsubproblems, - ) +function SCIPsetSortPricers(set) + ccall((:SCIPsetSortPricers, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPincludeCutselHybrid(scip) - ccall((:SCIPincludeCutselHybrid, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSortPricersName(set) + ccall((:SCIPsetSortPricersName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPselectCutsHybrid( - scip, - cuts, - forcedcuts, - randnumgen, - goodscorefac, - badscorefac, - goodmaxparall, - maxparall, - dircutoffdistweight, - efficacyweight, - objparalweight, - intsupportweight, - ncuts, - nforcedcuts, - maxselectedcuts, - nselectedcuts, -) - ccall( - (:SCIPselectCutsHybrid, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_ROW}}, - Ptr{Ptr{SCIP_ROW}}, - Ptr{SCIP_RANDNUMGEN}, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cdouble, - Cint, - Cint, - Cint, - Ptr{Cint}, - ), - scip, - cuts, - forcedcuts, - randnumgen, - goodscorefac, - badscorefac, - goodmaxparall, - maxparall, - dircutoffdistweight, - efficacyweight, - objparalweight, - intsupportweight, - ncuts, - nforcedcuts, - maxselectedcuts, - nselectedcuts, - ) +function SCIPsetIncludeBenders(set, benders) + ccall((:SCIPsetIncludeBenders, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_BENDERS}), set, benders) end -function SCIPincludeExprhdlrVaridx(scip) - ccall( - (:SCIPincludeExprhdlrVaridx, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetFindBenders(set, name) + ccall((:SCIPsetFindBenders, libscip), Ptr{SCIP_BENDERS}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPcreateExprVaridx(scip, expr, varidx, ownercreate, ownercreatedata) - ccall( - (:SCIPcreateExprVaridx, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Cvoid}, Ptr{Cvoid}), - scip, - expr, - varidx, - ownercreate, - ownercreatedata, - ) +function SCIPsetSortBenders(set) + ccall((:SCIPsetSortBenders, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPisExprVaridx(scip, expr) - ccall( - (:SCIPisExprVaridx, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_EXPR}), - scip, - expr, - ) +function SCIPsetSortBendersName(set) + ccall((:SCIPsetSortBendersName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPgetIndexExprVaridx(expr) - ccall((:SCIPgetIndexExprVaridx, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +function SCIPsetIncludeConshdlr(set, conshdlr) + ccall((:SCIPsetIncludeConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CONSHDLR}), set, conshdlr) end -function SCIPsetIndexExprVaridx(expr, newindex) - ccall( - (:SCIPsetIndexExprVaridx, libscip), - Cvoid, - (Ptr{SCIP_EXPR}, Cint), - expr, - newindex, - ) +function SCIPsetReinsertConshdlrSepaPrio(set, conshdlr, oldpriority) + ccall((:SCIPsetReinsertConshdlrSepaPrio, libscip), Cvoid, (Ptr{SCIP_SET}, Ptr{SCIP_CONSHDLR}, Cint), set, conshdlr, oldpriority) end -function SCIPincludeNlpSolverIpopt(scip) - ccall( - (:SCIPincludeNlpSolverIpopt, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetFindConshdlr(set, name) + ccall((:SCIPsetFindConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPgetSolverNameIpopt() - ccall((:SCIPgetSolverNameIpopt, libscip), Ptr{Cchar}, ()) +function SCIPsetIncludeConflicthdlr(set, conflicthdlr) + ccall((:SCIPsetIncludeConflicthdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CONFLICTHDLR}), set, conflicthdlr) end -function SCIPgetSolverDescIpopt() - ccall((:SCIPgetSolverDescIpopt, libscip), Ptr{Cchar}, ()) +function SCIPsetFindConflicthdlr(set, name) + ccall((:SCIPsetFindConflicthdlr, libscip), Ptr{SCIP_CONFLICTHDLR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPisIpoptAvailableIpopt() - ccall((:SCIPisIpoptAvailableIpopt, libscip), Cuint, ()) +function SCIPsetSortConflicthdlrs(set) + ccall((:SCIPsetSortConflicthdlrs, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPgetNlpiOracleIpopt(nlpiproblem) - ccall( - (:SCIPgetNlpiOracleIpopt, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_NLPIPROBLEM},), - nlpiproblem, - ) +function SCIPsetSortConflicthdlrsName(set) + ccall((:SCIPsetSortConflicthdlrsName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPcallLapackDsyevIpopt(computeeigenvectors, N, a, w) - ccall( - (:SCIPcallLapackDsyevIpopt, libscip), - SCIP_RETCODE, - (Cuint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), - computeeigenvectors, - N, - a, - w, - ) +function SCIPsetIncludePresol(set, presol) + ccall((:SCIPsetIncludePresol, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_PRESOL}), set, presol) end -function SCIPsolveLinearEquationsIpopt(N, A, b, x, success) - ccall( - (:SCIPsolveLinearEquationsIpopt, libscip), - SCIP_RETCODE, - (Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), - N, - A, - b, - x, - success, - ) +function SCIPsetFindPresol(set, name) + ccall((:SCIPsetFindPresol, libscip), Ptr{SCIP_PRESOL}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPincludeNlpSolverFilterSQP(scip) - ccall( - (:SCIPincludeNlpSolverFilterSQP, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetSortPresols(set) + ccall((:SCIPsetSortPresols, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPgetSolverNameFilterSQP() - ccall((:SCIPgetSolverNameFilterSQP, libscip), Ptr{Cchar}, ()) +function SCIPsetSortPresolsName(set) + ccall((:SCIPsetSortPresolsName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPgetSolverDescFilterSQP() - ccall((:SCIPgetSolverDescFilterSQP, libscip), Ptr{Cchar}, ()) +function SCIPsetIncludeRelax(set, relax) + ccall((:SCIPsetIncludeRelax, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_RELAX}), set, relax) end -function SCIPisFilterSQPAvailableFilterSQP() - ccall((:SCIPisFilterSQPAvailableFilterSQP, libscip), Cuint, ()) +function SCIPsetFindRelax(set, name) + ccall((:SCIPsetFindRelax, libscip), Ptr{SCIP_RELAX}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPincludeNlpSolverWorhp(scip, useip) - ccall( - (:SCIPincludeNlpSolverWorhp, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Cuint), - scip, - useip, - ) +function SCIPsetSortRelaxs(set) + ccall((:SCIPsetSortRelaxs, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPgetSolverNameWorhp() - ccall((:SCIPgetSolverNameWorhp, libscip), Ptr{Cchar}, ()) +function SCIPsetSortRelaxsName(set) + ccall((:SCIPsetSortRelaxsName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPgetSolverDescWorhp() - ccall((:SCIPgetSolverDescWorhp, libscip), Ptr{Cchar}, ()) +function SCIPsetIncludeSepa(set, sepa) + ccall((:SCIPsetIncludeSepa, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_SEPA}), set, sepa) end -function SCIPisWorhpAvailableWorhp() - ccall((:SCIPisWorhpAvailableWorhp, libscip), Cuint, ()) +function SCIPsetFindSepa(set, name) + ccall((:SCIPsetFindSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPincludeNlpSolverAll(scip) - ccall((:SCIPincludeNlpSolverAll, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +function SCIPsetSortSepas(set) + ccall((:SCIPsetSortSepas, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPincludeDefaultPlugins(scip) - ccall( - (:SCIPincludeDefaultPlugins, libscip), - SCIP_RETCODE, - (Ptr{SCIP},), - scip, - ) +function SCIPsetSortSepasName(set) + ccall((:SCIPsetSortSepasName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbanditSelect(bandit, action) - ccall( - (:SCIPbanditSelect, libscip), - SCIP_RETCODE, - (Ptr{SCIP_BANDIT}, Ptr{Cint}), - bandit, - action, - ) +function SCIPsetIncludeCutsel(set, cutsel) + ccall((:SCIPsetIncludeCutsel, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CUTSEL}), set, cutsel) end -function SCIPbanditUpdate(bandit, action, score) - ccall( - (:SCIPbanditUpdate, libscip), - SCIP_RETCODE, - (Ptr{SCIP_BANDIT}, Cint, Cdouble), - bandit, - action, - score, - ) +function SCIPsetFindCutsel(set, name) + ccall((:SCIPsetFindCutsel, libscip), Ptr{SCIP_CUTSEL}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbanditvtableGetName(banditvtable) - ccall( - (:SCIPbanditvtableGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_BANDITVTABLE},), - banditvtable, - ) +function SCIPsetSortCutsels(set) + ccall((:SCIPsetSortCutsels, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbanditGetRandnumgen(bandit) - ccall( - (:SCIPbanditGetRandnumgen, libscip), - Ptr{SCIP_RANDNUMGEN}, - (Ptr{SCIP_BANDIT},), - bandit, - ) +function SCIPsetIncludeProp(set, prop) + ccall((:SCIPsetIncludeProp, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_PROP}), set, prop) end -function SCIPbanditGetNActions(bandit) - ccall((:SCIPbanditGetNActions, libscip), Cint, (Ptr{SCIP_BANDIT},), bandit) +function SCIPsetFindProp(set, name) + ccall((:SCIPsetFindProp, libscip), Ptr{SCIP_PROP}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -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, - Cuint, - Cdouble, - Cint, - Cint, - Cuint, - ), - scip, - epsgreedy, - priorities, - eps, - preferrecent, - decayfactor, - avglim, - nactions, - initseed, - ) +function SCIPsetSortProps(set) + ccall((:SCIPsetSortProps, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPgetWeightsEpsgreedy(epsgreedy) - ccall( - (:SCIPgetWeightsEpsgreedy, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_BANDIT},), - epsgreedy, - ) +function SCIPsetSortPropsPresol(set) + ccall((:SCIPsetSortPropsPresol, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPsetEpsilonEpsgreedy(epsgreedy, eps) - ccall( - (:SCIPsetEpsilonEpsgreedy, libscip), - Cvoid, - (Ptr{SCIP_BANDIT}, Cdouble), - epsgreedy, - eps, - ) -end - -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, - Cuint, - ), - scip, - exp3, - priorities, - gammaparam, - beta, - nactions, - initseed, - ) +function SCIPsetSortPropsName(set) + ccall((:SCIPsetSortPropsName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPsetGammaExp3(exp3, gammaparam) - ccall( - (:SCIPsetGammaExp3, libscip), - Cvoid, - (Ptr{SCIP_BANDIT}, Cdouble), - exp3, - gammaparam, - ) +function SCIPsetIncludeConcsolverType(set, concsolvertype) + ccall((:SCIPsetIncludeConcsolverType, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CONCSOLVERTYPE}), set, concsolvertype) end -function SCIPsetBetaExp3(exp3, beta) - ccall( - (:SCIPsetBetaExp3, libscip), - Cvoid, - (Ptr{SCIP_BANDIT}, Cdouble), - exp3, - beta, - ) +function SCIPsetFindConcsolverType(set, name) + ccall((:SCIPsetFindConcsolverType, libscip), Ptr{SCIP_CONCSOLVERTYPE}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPgetProbabilityExp3(exp3, action) - ccall( - (:SCIPgetProbabilityExp3, libscip), - Cdouble, - (Ptr{SCIP_BANDIT}, Cint), - exp3, - action, - ) +function SCIPsetIncludeConcsolver(set, concsolver) + ccall((:SCIPsetIncludeConcsolver, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CONCSOLVER}), set, concsolver) end -function SCIPcreateBanditUcb(scip, ucb, priorities, alpha, nactions, initseed) - ccall( - (:SCIPcreateBanditUcb, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, Cint, Cuint), - scip, - ucb, - priorities, - alpha, - nactions, - initseed, - ) +function SCIPsetFreeConcsolvers(set) + ccall((:SCIPsetFreeConcsolvers, libscip), SCIP_RETCODE, (Ptr{SCIP_SET},), set) end -function SCIPgetConfidenceBoundUcb(ucb, action) - ccall( - (:SCIPgetConfidenceBoundUcb, libscip), - Cdouble, - (Ptr{SCIP_BANDIT}, Cint), - ucb, - action, - ) +function SCIPsetIncludeHeur(set, heur) + ccall((:SCIPsetIncludeHeur, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_HEUR}), set, heur) end -function SCIPgetStartPermutationUcb(ucb) - ccall( - (:SCIPgetStartPermutationUcb, libscip), - Ptr{Cint}, - (Ptr{SCIP_BANDIT},), - ucb, - ) +function SCIPsetFindHeur(set, name) + ccall((:SCIPsetFindHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersComp(elem1, elem2) - ccall( - (:SCIPbendersComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetSortHeurs(set) + ccall((:SCIPsetSortHeurs, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersCompName(elem1, elem2) - ccall( - (:SCIPbendersCompName, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetSortHeursName(set) + ccall((:SCIPsetSortHeursName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersGetData(benders) - ccall( - (:SCIPbendersGetData, libscip), - Ptr{SCIP_BENDERSDATA}, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetIncludeCompr(set, compr) + ccall((:SCIPsetIncludeCompr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_COMPR}), set, compr) end -function SCIPbendersSetData(benders, bendersdata) - ccall( - (:SCIPbendersSetData, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Ptr{SCIP_BENDERSDATA}), - benders, - bendersdata, - ) +function SCIPsetFindCompr(set, name) + ccall((:SCIPsetFindCompr, libscip), Ptr{SCIP_COMPR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersGetName(benders) - ccall( - (:SCIPbendersGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetSortComprs(set) + ccall((:SCIPsetSortComprs, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersGetDesc(benders) - ccall( - (:SCIPbendersGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetSortComprsName(set) + ccall((:SCIPsetSortComprsName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersGetPriority(benders) - ccall( - (:SCIPbendersGetPriority, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetIncludeEventhdlr(set, eventhdlr) + ccall((:SCIPsetIncludeEventhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_EVENTHDLR}), set, eventhdlr) end -function SCIPbendersGetNSubproblems(benders) - ccall( - (:SCIPbendersGetNSubproblems, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetFindEventhdlr(set, name) + ccall((:SCIPsetFindEventhdlr, libscip), Ptr{SCIP_EVENTHDLR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersSubproblem(benders, probnumber) - ccall( - (:SCIPbendersSubproblem, libscip), - Ptr{SCIP}, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetIncludeNodesel(set, nodesel) + ccall((:SCIPsetIncludeNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), set, nodesel) end -function SCIPbendersGetNCalls(benders) - ccall((:SCIPbendersGetNCalls, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +function SCIPsetFindNodesel(set, name) + ccall((:SCIPsetFindNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersGetNCutsFound(benders) - ccall( - (:SCIPbendersGetNCutsFound, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetGetNodesel(set, stat) + ccall((:SCIPsetGetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_SET}, Ptr{SCIP_STAT}), set, stat) end -function SCIPbendersGetNStrengthenCutsFound(benders) - ccall( - (:SCIPbendersGetNStrengthenCutsFound, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetIncludeBranchrule(set, branchrule) + ccall((:SCIPsetIncludeBranchrule, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_BRANCHRULE}), set, branchrule) end -function SCIPbendersGetNStrengthenCalls(benders) - ccall( - (:SCIPbendersGetNStrengthenCalls, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetFindBranchrule(set, name) + ccall((:SCIPsetFindBranchrule, libscip), Ptr{SCIP_BRANCHRULE}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersGetNStrengthenFails(benders) - ccall( - (:SCIPbendersGetNStrengthenFails, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetSortBranchrules(set) + ccall((:SCIPsetSortBranchrules, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersGetSetupTime(benders) - ccall( - (:SCIPbendersGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetSortBranchrulesName(set) + ccall((:SCIPsetSortBranchrulesName, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersGetTime(benders) - ccall( - (:SCIPbendersGetTime, libscip), - Cdouble, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetIncludeIISfinder(set, iisfinder) + ccall((:SCIPsetIncludeIISfinder, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_IISFINDER}), set, iisfinder) end -function SCIPbendersIsInitialized(benders) - ccall( - (:SCIPbendersIsInitialized, libscip), - Cuint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetFindIISfinder(set, name) + ccall((:SCIPsetFindIISfinder, libscip), Ptr{SCIP_IISFINDER}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersIsActive(benders) - ccall((:SCIPbendersIsActive, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +function SCIPsetSortIISfinders(set) + ccall((:SCIPsetSortIISfinders, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersOnlyCheckConvexRelax(benders, subscipsoff) - ccall( - (:SCIPbendersOnlyCheckConvexRelax, libscip), - Cuint, - (Ptr{SCIP_BENDERS}, Cuint), - benders, - subscipsoff, - ) +function SCIPsetIncludeDisp(set, disp) + ccall((:SCIPsetIncludeDisp, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_DISP}), set, disp) end -function SCIPbendersCutLP(benders) - ccall((:SCIPbendersCutLP, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +function SCIPsetFindDisp(set, name) + ccall((:SCIPsetFindDisp, libscip), Ptr{SCIP_DISP}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersCutPseudo(benders) - ccall( - (:SCIPbendersCutPseudo, libscip), - Cuint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetIncludeTable(set, table) + ccall((:SCIPsetIncludeTable, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_TABLE}), set, table) end -function SCIPbendersCutRelaxation(benders) - ccall( - (:SCIPbendersCutRelaxation, libscip), - Cuint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetFindTable(set, name) + ccall((:SCIPsetFindTable, libscip), Ptr{SCIP_TABLE}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersShareAuxVars(benders) - ccall( - (:SCIPbendersShareAuxVars, libscip), - Cuint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetIncludeDialog(set, dialog) + ccall((:SCIPsetIncludeDialog, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_DIALOG}), set, dialog) end -function SCIPbendersSetSubproblemIsSetup(benders, probnumber, issetup) - ccall( - (:SCIPbendersSetSubproblemIsSetup, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Cint, Cuint), - benders, - probnumber, - issetup, - ) +function SCIPsetExistsDialog(set, dialog) + ccall((:SCIPsetExistsDialog, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_DIALOG}), set, dialog) end -function SCIPbendersSubproblemIsSetup(benders, probnumber) - ccall( - (:SCIPbendersSubproblemIsSetup, libscip), - Cuint, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetIncludeExprhdlr(set, exprhdlr) + ccall((:SCIPsetIncludeExprhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_EXPRHDLR}), set, exprhdlr) end -function SCIPbendersGetAuxiliaryVar(benders, probnumber) - ccall( - (:SCIPbendersGetAuxiliaryVar, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetFindExprhdlr(set, name) + ccall((:SCIPsetFindExprhdlr, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersGetAuxiliaryVars(benders) - ccall( - (:SCIPbendersGetAuxiliaryVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetSortExprhdlrs(set) + ccall((:SCIPsetSortExprhdlrs, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersSetSubproblemObjval(benders, probnumber, objval) - ccall( - (:SCIPbendersSetSubproblemObjval, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Cint, Cdouble), - benders, - probnumber, - objval, - ) +function SCIPsetIncludeNlpi(set, nlpi) + ccall((:SCIPsetIncludeNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}), set, nlpi) end -function SCIPbendersGetSubproblemObjval(benders, probnumber) - ccall( - (:SCIPbendersGetSubproblemObjval, libscip), - Cdouble, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetFindNlpi(set, name) + ccall((:SCIPsetFindNlpi, libscip), Ptr{SCIP_NLPI}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersGetNStoredCuts(benders) - ccall( - (:SCIPbendersGetNStoredCuts, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) -end - -function SCIPbendersGetStoredCutData( - benders, - cutidx, - vars, - vals, - lhs, - rhs, - nvars, -) - ccall( - (:SCIPbendersGetStoredCutData, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_BENDERS}, - Cint, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - ), - benders, - cutidx, - vars, - vals, - lhs, - rhs, - nvars, - ) -end - -function SCIPbendersGetStoredCutOrigData( - benders, - cutidx, - vars, - vals, - lhs, - rhs, - nvars, - varssize, -) - ccall( - (:SCIPbendersGetStoredCutOrigData, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_BENDERS}, - Cint, - Ptr{Ptr{Ptr{SCIP_VAR}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Cint, - ), - benders, - cutidx, - vars, - vals, - lhs, - rhs, - nvars, - varssize, - ) +function SCIPsetSortNlpis(set) + ccall((:SCIPsetSortNlpis, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPfindBenderscut(benders, name) - ccall( - (:SCIPfindBenderscut, libscip), - Ptr{SCIP_BENDERSCUT}, - (Ptr{SCIP_BENDERS}, Ptr{Cchar}), - benders, - name, - ) +function SCIPsetSetPriorityNlpi(set, nlpi, priority) + ccall((:SCIPsetSetPriorityNlpi, libscip), Cvoid, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Cint), set, nlpi, priority) end -function SCIPbendersGetBenderscuts(benders) - ccall( - (:SCIPbendersGetBenderscuts, libscip), - Ptr{Ptr{SCIP_BENDERSCUT}}, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetIncludeExternalCode(set, name, description) + ccall((:SCIPsetIncludeExternalCode, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cchar}), set, name, description) end -function SCIPbendersGetNBenderscuts(benders) - ccall( - (:SCIPbendersGetNBenderscuts, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetIncludeBanditvtable(set, banditvtable) + ccall((:SCIPsetIncludeBanditvtable, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_BANDITVTABLE}), set, banditvtable) end -function SCIPbendersSetBenderscutPriority(benders, benderscut, priority) - ccall( - (:SCIPbendersSetBenderscutPriority, libscip), - SCIP_RETCODE, - (Ptr{SCIP_BENDERS}, Ptr{SCIP_BENDERSCUT}, Cint), - benders, - benderscut, - priority, - ) +function SCIPsetFindBanditvtable(set, name) + ccall((:SCIPsetFindBanditvtable, libscip), Ptr{SCIP_BANDITVTABLE}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) end -function SCIPbendersSolSlackVarsActive(benders, activeslack) - ccall( - (:SCIPbendersSolSlackVarsActive, libscip), - SCIP_RETCODE, - (Ptr{SCIP_BENDERS}, Ptr{Cuint}), - benders, - activeslack, - ) +function SCIPsetInitPlugins(set, blkmem, stat) + ccall((:SCIPsetInitPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) end -function SCIPbendersSetSubproblemType(benders, probnumber, subprobtype) - ccall( - (:SCIPbendersSetSubproblemType, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Cint, SCIP_BENDERSSUBTYPE), - benders, - probnumber, - subprobtype, - ) +function SCIPsetExitPlugins(set, blkmem, stat) + ccall((:SCIPsetExitPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) end -function SCIPbendersGetSubproblemType(benders, probnumber) - ccall( - (:SCIPbendersGetSubproblemType, libscip), - SCIP_BENDERSSUBTYPE, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetInitprePlugins(set, blkmem, stat) + ccall((:SCIPsetInitprePlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) end -function SCIPbendersSetSubproblemIsConvex(benders, probnumber, isconvex) - ccall( - (:SCIPbendersSetSubproblemIsConvex, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Cint, Cuint), - benders, - probnumber, - isconvex, - ) +function SCIPsetExitprePlugins(set, blkmem, stat) + ccall((:SCIPsetExitprePlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) end -function SCIPbendersSubproblemIsConvex(benders, probnumber) - ccall( - (:SCIPbendersSubproblemIsConvex, libscip), - Cuint, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetInitsolPlugins(set, blkmem, stat) + ccall((:SCIPsetInitsolPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) end -function SCIPbendersGetNConvexSubproblems(benders) - ccall( - (:SCIPbendersGetNConvexSubproblems, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetExitsolPlugins(set, blkmem, stat, restart) + ccall((:SCIPsetExitsolPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Cuint), set, blkmem, stat, restart) end -function SCIPbendersSetSubproblemIsNonlinear(benders, probnumber, isnonlinear) - ccall( - (:SCIPbendersSetSubproblemIsNonlinear, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Cint, Cuint), - benders, - probnumber, - isnonlinear, - ) +function SCIPsetCalcMemGrowSize(set, num) + ccall((:SCIPsetCalcMemGrowSize, libscip), Cint, (Ptr{SCIP_SET}, Cint), set, num) end -function SCIPbendersSubproblemIsNonlinear(benders, probnumber) - ccall( - (:SCIPbendersSubproblemIsNonlinear, libscip), - Cuint, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetCalcTreeGrowSize(set, num) + ccall((:SCIPsetCalcTreeGrowSize, libscip), Cint, (Ptr{SCIP_SET}, Cint), set, num) end -function SCIPbendersGetNNonlinearSubproblems(benders) - ccall( - (:SCIPbendersGetNNonlinearSubproblems, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetCalcPathGrowSize(set, num) + ccall((:SCIPsetCalcPathGrowSize, libscip), Cint, (Ptr{SCIP_SET}, Cint), set, num) end -function SCIPbendersSetMasterIsNonlinear(benders, isnonlinear) - ccall( - (:SCIPbendersSetMasterIsNonlinear, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Cuint), - benders, - isnonlinear, - ) +function SCIPsetSetVerbLevel(set, verblevel) + ccall((:SCIPsetSetVerbLevel, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, SCIP_VERBLEVEL), set, verblevel) end -function SCIPbendersMasterIsNonlinear(benders) - ccall( - (:SCIPbendersMasterIsNonlinear, libscip), - Cuint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetSetFeastol(set, lp, feastol) + ccall((:SCIPsetSetFeastol, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), set, lp, feastol) end -function SCIPbendersInStrengthenRound(benders) - ccall( - (:SCIPbendersInStrengthenRound, libscip), - Cuint, - (Ptr{SCIP_BENDERS},), - benders, - ) -end - -function SCIPbendersSolveSubproblemLP( - scip, - benders, - probnumber, - solvestatus, - objective, -) - ccall( - (:SCIPbendersSolveSubproblemLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{SCIP_STATUS}, Ptr{Cdouble}), - scip, - benders, - probnumber, - solvestatus, - objective, - ) -end - -function SCIPbendersSolveSubproblemCIP( - scip, - benders, - probnumber, - solvestatus, - solvecip, -) - ccall( - (:SCIPbendersSolveSubproblemCIP, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{SCIP_STATUS}, Cuint), - scip, - benders, - probnumber, - solvestatus, - solvecip, - ) +function SCIPsetSetDualfeastol(set, dualfeastol) + ccall((:SCIPsetSetDualfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Cdouble), set, dualfeastol) end -function SCIPbendersGetNTransferredCuts(benders) - ccall( - (:SCIPbendersGetNTransferredCuts, libscip), - Cint, - (Ptr{SCIP_BENDERS},), - benders, - ) +function SCIPsetSetBarrierconvtol(set, barrierconvtol) + ccall((:SCIPsetSetBarrierconvtol, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Cdouble), set, barrierconvtol) end -function SCIPbendersUpdateSubproblemLowerbound(benders, probnumber, lowerbound) - ccall( - (:SCIPbendersUpdateSubproblemLowerbound, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Cint, Cdouble), - benders, - probnumber, - lowerbound, - ) +function SCIPsetSetRelaxfeastol(set, relaxfeastol) + ccall((:SCIPsetSetRelaxfeastol, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, relaxfeastol) end -function SCIPbendersGetSubproblemLowerbound(benders, probnumber) - ccall( - (:SCIPbendersGetSubproblemLowerbound, libscip), - Cdouble, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetSetLimitChanged(set) + ccall((:SCIPsetSetLimitChanged, libscip), Cvoid, (Ptr{SCIP_SET},), set) end -function SCIPbendersSetSubproblemIsIndependent(benders, probnumber, isindep) - ccall( - (:SCIPbendersSetSubproblemIsIndependent, libscip), - Cvoid, - (Ptr{SCIP_BENDERS}, Cint, Cuint), - benders, - probnumber, - isindep, - ) +function SCIPsetGetPriceMaxvars(set, root) + ccall((:SCIPsetGetPriceMaxvars, libscip), Cint, (Ptr{SCIP_SET}, Cuint), set, root) end -function SCIPbendersSubproblemIsIndependent(benders, probnumber) - ccall( - (:SCIPbendersSubproblemIsIndependent, libscip), - Cuint, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetGetSepaMaxcutsGenFactor(set, root) + ccall((:SCIPsetGetSepaMaxcutsGenFactor, libscip), Cdouble, (Ptr{SCIP_SET}, Cuint), set, root) end -function SCIPbendersSubproblemIsEnabled(benders, probnumber) - ccall( - (:SCIPbendersSubproblemIsEnabled, libscip), - Cuint, - (Ptr{SCIP_BENDERS}, Cint), - benders, - probnumber, - ) +function SCIPsetGetSepaMaxcuts(set, root) + ccall((:SCIPsetGetSepaMaxcuts, libscip), Cint, (Ptr{SCIP_SET}, Cuint), set, root) end -function SCIPbenderscutComp(elem1, elem2) - ccall( - (:SCIPbenderscutComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetGetSepaMaxCoefRatioRowprep(set) + ccall((:SCIPsetGetSepaMaxCoefRatioRowprep, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutCompName(elem1, elem2) - ccall( - (:SCIPbenderscutCompName, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetGetReferencevalue(set) + ccall((:SCIPsetGetReferencevalue, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutGetData(benderscut) - ccall( - (:SCIPbenderscutGetData, libscip), - Ptr{SCIP_BENDERSCUTDATA}, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetGetDebugSolData(set) + ccall((:SCIPsetGetDebugSolData, libscip), Ptr{SCIP_DEBUGSOLDATA}, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutSetData(benderscut, benderscutdata) - ccall( - (:SCIPbenderscutSetData, libscip), - Cvoid, - (Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_BENDERSCUTDATA}), - benderscut, - benderscutdata, - ) +function SCIPsetIsUpdateUnreliable(set, newvalue, oldvalue) + ccall((:SCIPsetIsUpdateUnreliable, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, newvalue, oldvalue) end -function SCIPbenderscutGetName(benderscut) - ccall( - (:SCIPbenderscutGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetInitializeRandomSeed(set, initialseedvalue) + ccall((:SCIPsetInitializeRandomSeed, libscip), Cuint, (Ptr{SCIP_SET}, Cuint), set, initialseedvalue) end -function SCIPbenderscutGetDesc(benderscut) - ccall( - (:SCIPbenderscutGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetInfinity(set) + ccall((:SCIPsetInfinity, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutGetPriority(benderscut) - ccall( - (:SCIPbenderscutGetPriority, libscip), - Cint, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetGetHugeValue(set) + ccall((:SCIPsetGetHugeValue, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutGetNCalls(benderscut) - ccall( - (:SCIPbenderscutGetNCalls, libscip), - Clonglong, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetEpsilon(set) + ccall((:SCIPsetEpsilon, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutGetNFound(benderscut) - ccall( - (:SCIPbenderscutGetNFound, libscip), - Clonglong, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetSumepsilon(set) + ccall((:SCIPsetSumepsilon, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutIsInitialized(benderscut) - ccall( - (:SCIPbenderscutIsInitialized, libscip), - Cuint, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetFeastol(set) + ccall((:SCIPsetFeastol, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutGetSetupTime(benderscut) - ccall( - (:SCIPbenderscutGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetLPFeastolFactor(set) + ccall((:SCIPsetLPFeastolFactor, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutGetTime(benderscut) - ccall( - (:SCIPbenderscutGetTime, libscip), - Cdouble, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetDualfeastol(set) + ccall((:SCIPsetDualfeastol, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutIsLPCut(benderscut) - ccall( - (:SCIPbenderscutIsLPCut, libscip), - Cuint, - (Ptr{SCIP_BENDERSCUT},), - benderscut, - ) +function SCIPsetBarrierconvtol(set) + ccall((:SCIPsetBarrierconvtol, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbenderscutSetEnabled(benderscut, enabled) - ccall( - (:SCIPbenderscutSetEnabled, libscip), - Cvoid, - (Ptr{SCIP_BENDERSCUT}, Cuint), - benderscut, - enabled, - ) +function SCIPsetPseudocosteps(set) + ccall((:SCIPsetPseudocosteps, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbranchruleComp(elem1, elem2) - ccall( - (:SCIPbranchruleComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetPseudocostdelta(set) + ccall((:SCIPsetPseudocostdelta, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbranchruleCompName(elem1, elem2) - ccall( - (:SCIPbranchruleCompName, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetCutoffbounddelta(set) + ccall((:SCIPsetCutoffbounddelta, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbranchruleGetData(branchrule) - ccall( - (:SCIPbranchruleGetData, libscip), - Ptr{SCIP_BRANCHRULEDATA}, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetRelaxfeastol(set) + ccall((:SCIPsetRelaxfeastol, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbranchruleSetData(branchrule, branchruledata) - ccall( - (:SCIPbranchruleSetData, libscip), - Cvoid, - (Ptr{SCIP_BRANCHRULE}, Ptr{SCIP_BRANCHRULEDATA}), - branchrule, - branchruledata, - ) +function SCIPsetRecompfac(set) + ccall((:SCIPsetRecompfac, libscip), Cdouble, (Ptr{SCIP_SET},), set) end -function SCIPbranchruleGetName(branchrule) - ccall( - (:SCIPbranchruleGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsEQ(set, val1, val2) + ccall((:SCIPsetIsEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPbranchruleGetDesc(branchrule) - ccall( - (:SCIPbranchruleGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsLT(set, val1, val2) + ccall((:SCIPsetIsLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPbranchruleGetPriority(branchrule) - ccall( - (:SCIPbranchruleGetPriority, libscip), - Cint, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsLE(set, val1, val2) + ccall((:SCIPsetIsLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPbranchruleGetMaxdepth(branchrule) - ccall( - (:SCIPbranchruleGetMaxdepth, libscip), - Cint, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsGT(set, val1, val2) + ccall((:SCIPsetIsGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPbranchruleGetMaxbounddist(branchrule) - ccall( - (:SCIPbranchruleGetMaxbounddist, libscip), - Cdouble, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsGE(set, val1, val2) + ccall((:SCIPsetIsGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPbranchruleGetSetupTime(branchrule) - ccall( - (:SCIPbranchruleGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsInfinity(set, val) + ccall((:SCIPsetIsInfinity, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleGetTime(branchrule) - ccall( - (:SCIPbranchruleGetTime, libscip), - Cdouble, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsHugeValue(set, val) + ccall((:SCIPsetIsHugeValue, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleGetNLPCalls(branchrule) - ccall( - (:SCIPbranchruleGetNLPCalls, libscip), - Clonglong, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsZero(set, val) + ccall((:SCIPsetIsZero, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleGetNExternCalls(branchrule) - ccall( - (:SCIPbranchruleGetNExternCalls, libscip), - Clonglong, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsPositive(set, val) + ccall((:SCIPsetIsPositive, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleGetNPseudoCalls(branchrule) - ccall( - (:SCIPbranchruleGetNPseudoCalls, libscip), - Clonglong, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsNegative(set, val) + ccall((:SCIPsetIsNegative, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleGetNCutoffs(branchrule) - ccall( - (:SCIPbranchruleGetNCutoffs, libscip), - Clonglong, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsIntegral(set, val) + ccall((:SCIPsetIsIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleGetNCutsFound(branchrule) - ccall( - (:SCIPbranchruleGetNCutsFound, libscip), - Clonglong, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsScalingIntegral(set, val, scalar) + ccall((:SCIPsetIsScalingIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val, scalar) end -function SCIPbranchruleGetNConssFound(branchrule) - ccall( - (:SCIPbranchruleGetNConssFound, libscip), - Clonglong, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetIsFracIntegral(set, val) + ccall((:SCIPsetIsFracIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleGetNDomredsFound(branchrule) - ccall( - (:SCIPbranchruleGetNDomredsFound, libscip), - Clonglong, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetFloor(set, val) + ccall((:SCIPsetFloor, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleGetNChildren(branchrule) - ccall( - (:SCIPbranchruleGetNChildren, libscip), - Clonglong, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetCeil(set, val) + ccall((:SCIPsetCeil, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPbranchruleIsInitialized(branchrule) - ccall( - (:SCIPbranchruleIsInitialized, libscip), - Cuint, - (Ptr{SCIP_BRANCHRULE},), - branchrule, - ) +function SCIPsetRound(set, val) + ccall((:SCIPsetRound, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPcomprComp(elem1, elem2) - ccall( - (:SCIPcomprComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetFrac(set, val) + ccall((:SCIPsetFrac, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPcomprCompName(elem1, elem2) - ccall( - (:SCIPcomprCompName, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetIsSumEQ(set, val1, val2) + ccall((:SCIPsetIsSumEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPcomprGetData(compr) - ccall( - (:SCIPcomprGetData, libscip), - Ptr{SCIP_COMPRDATA}, - (Ptr{SCIP_COMPR},), - compr, - ) +function SCIPsetIsSumLT(set, val1, val2) + ccall((:SCIPsetIsSumLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPcomprSetData(compr, comprdata) - ccall( - (:SCIPcomprSetData, libscip), - Cvoid, - (Ptr{SCIP_COMPR}, Ptr{SCIP_COMPRDATA}), - compr, - comprdata, - ) +function SCIPsetIsSumLE(set, val1, val2) + ccall((:SCIPsetIsSumLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPcomprGetName(heur) - ccall((:SCIPcomprGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_COMPR},), heur) +function SCIPsetIsSumGT(set, val1, val2) + ccall((:SCIPsetIsSumGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPcomprGetDesc(compr) - ccall((:SCIPcomprGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_COMPR},), compr) +function SCIPsetIsSumGE(set, val1, val2) + ccall((:SCIPsetIsSumGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPcomprGetPriority(compr) - ccall((:SCIPcomprGetPriority, libscip), Cint, (Ptr{SCIP_COMPR},), compr) +function SCIPsetIsSumZero(set, val) + ccall((:SCIPsetIsSumZero, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPcomprGetMinNodes(compr) - ccall((:SCIPcomprGetMinNodes, libscip), Cint, (Ptr{SCIP_COMPR},), compr) +function SCIPsetIsSumPositive(set, val) + ccall((:SCIPsetIsSumPositive, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPcomprGetNCalls(compr) - ccall((:SCIPcomprGetNCalls, libscip), Clonglong, (Ptr{SCIP_COMPR},), compr) +function SCIPsetIsSumNegative(set, val) + ccall((:SCIPsetIsSumNegative, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPcomprGetNFound(compr) - ccall((:SCIPcomprGetNFound, libscip), Clonglong, (Ptr{SCIP_COMPR},), compr) +function SCIPsetSumFloor(set, val) + ccall((:SCIPsetSumFloor, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPcomprIsInitialized(compr) - ccall((:SCIPcomprIsInitialized, libscip), Cuint, (Ptr{SCIP_COMPR},), compr) +function SCIPsetSumCeil(set, val) + ccall((:SCIPsetSumCeil, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPcomprGetSetupTime(compr) - ccall((:SCIPcomprGetSetupTime, libscip), Cdouble, (Ptr{SCIP_COMPR},), compr) +function SCIPsetSumRound(set, val) + ccall((:SCIPsetSumRound, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPcomprGetTime(compr) - ccall((:SCIPcomprGetTime, libscip), Cdouble, (Ptr{SCIP_COMPR},), compr) +function SCIPsetSumFrac(set, val) + ccall((:SCIPsetSumFrac, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconflicthdlrComp(elem1, elem2) - ccall( - (:SCIPconflicthdlrComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetIsFeasEQ(set, val1, val2) + ccall((:SCIPsetIsFeasEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconflicthdlrCompName(elem1, elem2) - ccall( - (:SCIPconflicthdlrCompName, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetIsFeasLT(set, val1, val2) + ccall((:SCIPsetIsFeasLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconflicthdlrGetData(conflicthdlr) - ccall( - (:SCIPconflicthdlrGetData, libscip), - Ptr{SCIP_CONFLICTHDLRDATA}, - (Ptr{SCIP_CONFLICTHDLR},), - conflicthdlr, - ) +function SCIPsetIsFeasLE(set, val1, val2) + ccall((:SCIPsetIsFeasLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconflicthdlrSetData(conflicthdlr, conflicthdlrdata) - ccall( - (:SCIPconflicthdlrSetData, libscip), - Cvoid, - (Ptr{SCIP_CONFLICTHDLR}, Ptr{SCIP_CONFLICTHDLRDATA}), - conflicthdlr, - conflicthdlrdata, - ) +function SCIPsetIsFeasGT(set, val1, val2) + ccall((:SCIPsetIsFeasGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconflicthdlrGetName(conflicthdlr) - ccall( - (:SCIPconflicthdlrGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_CONFLICTHDLR},), - conflicthdlr, - ) +function SCIPsetIsFeasGE(set, val1, val2) + ccall((:SCIPsetIsFeasGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconflicthdlrGetDesc(conflicthdlr) - ccall( - (:SCIPconflicthdlrGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_CONFLICTHDLR},), - conflicthdlr, - ) +function SCIPsetIsFeasZero(set, val) + ccall((:SCIPsetIsFeasZero, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconflicthdlrGetPriority(conflicthdlr) - ccall( - (:SCIPconflicthdlrGetPriority, libscip), - Cint, - (Ptr{SCIP_CONFLICTHDLR},), - conflicthdlr, - ) +function SCIPsetIsFeasPositive(set, val) + ccall((:SCIPsetIsFeasPositive, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconflicthdlrIsInitialized(conflicthdlr) - ccall( - (:SCIPconflicthdlrIsInitialized, libscip), - Cuint, - (Ptr{SCIP_CONFLICTHDLR},), - conflicthdlr, - ) +function SCIPsetIsFeasNegative(set, val) + ccall((:SCIPsetIsFeasNegative, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconflicthdlrGetSetupTime(conflicthdlr) - ccall( - (:SCIPconflicthdlrGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_CONFLICTHDLR},), - conflicthdlr, - ) +function SCIPsetIsFeasIntegral(set, val) + ccall((:SCIPsetIsFeasIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconflicthdlrGetTime(conflicthdlr) - ccall( - (:SCIPconflicthdlrGetTime, libscip), - Cdouble, - (Ptr{SCIP_CONFLICTHDLR},), - conflicthdlr, - ) +function SCIPsetIsFeasFracIntegral(set, val) + ccall((:SCIPsetIsFeasFracIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrCompSepa(elem1, elem2) - ccall( - (:SCIPconshdlrCompSepa, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetFeasFloor(set, val) + ccall((:SCIPsetFeasFloor, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrCompEnfo(elem1, elem2) - ccall( - (:SCIPconshdlrCompEnfo, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetFeasCeil(set, val) + ccall((:SCIPsetFeasCeil, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrCompCheck(elem1, elem2) - ccall( - (:SCIPconshdlrCompCheck, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPsetFeasRound(set, val) + ccall((:SCIPsetFeasRound, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetName(conshdlr) - ccall( - (:SCIPconshdlrGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetFeasFrac(set, val) + ccall((:SCIPsetFeasFrac, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetDesc(conshdlr) - ccall( - (:SCIPconshdlrGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsDualfeasEQ(set, val1, val2) + ccall((:SCIPsetIsDualfeasEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetData(conshdlr) - ccall( - (:SCIPconshdlrGetData, libscip), - Ptr{SCIP_CONSHDLRDATA}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsDualfeasLT(set, val1, val2) + ccall((:SCIPsetIsDualfeasLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) 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, Cuint), - conshdlr, - conssepalp, - conssepasol, - sepafreq, - sepapriority, - delaysepa, - ) -end - -function SCIPconshdlrSetProp( - conshdlr, - consprop, - propfreq, - delayprop, - timingmask, -) - ccall( - (:SCIPconshdlrSetProp, libscip), - Cvoid, - (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, Cuint, SCIP_PROPTIMING), - conshdlr, - consprop, - propfreq, - delayprop, - timingmask, - ) +function SCIPsetIsDualfeasLE(set, val1, val2) + ccall((:SCIPsetIsDualfeasLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrSetEnforelax(conshdlr, consenforelax) - ccall( - (:SCIPconshdlrSetEnforelax, libscip), - Cvoid, - (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), - conshdlr, - consenforelax, - ) +function SCIPsetIsDualfeasGT(set, val1, val2) + ccall((:SCIPsetIsDualfeasGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetConss(conshdlr) - ccall( - (:SCIPconshdlrGetConss, libscip), - Ptr{Ptr{SCIP_CONS}}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsDualfeasGE(set, val1, val2) + ccall((:SCIPsetIsDualfeasGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetEnfoConss(conshdlr) - ccall( - (:SCIPconshdlrGetEnfoConss, libscip), - Ptr{Ptr{SCIP_CONS}}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsDualfeasZero(set, val) + ccall((:SCIPsetIsDualfeasZero, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetCheckConss(conshdlr) - ccall( - (:SCIPconshdlrGetCheckConss, libscip), - Ptr{Ptr{SCIP_CONS}}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsDualfeasPositive(set, val) + ccall((:SCIPsetIsDualfeasPositive, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetUpdateConss(conshdlr) - ccall( - (:SCIPconshdlrGetUpdateConss, libscip), - Ptr{Ptr{SCIP_CONS}}, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsDualfeasNegative(set, val) + ccall((:SCIPsetIsDualfeasNegative, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetNConss(conshdlr) - ccall( - (:SCIPconshdlrGetNConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsDualfeasIntegral(set, val) + ccall((:SCIPsetIsDualfeasIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetNEnfoConss(conshdlr) - ccall( - (:SCIPconshdlrGetNEnfoConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsDualfeasFracIntegral(set, val) + ccall((:SCIPsetIsDualfeasFracIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetNCheckConss(conshdlr) - ccall( - (:SCIPconshdlrGetNCheckConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetDualfeasFloor(set, val) + ccall((:SCIPsetDualfeasFloor, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetNActiveConss(conshdlr) - ccall( - (:SCIPconshdlrGetNActiveConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetDualfeasCeil(set, val) + ccall((:SCIPsetDualfeasCeil, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetNEnabledConss(conshdlr) - ccall( - (:SCIPconshdlrGetNEnabledConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetDualfeasRound(set, val) + ccall((:SCIPsetDualfeasRound, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetNUpdateConss(conshdlr) - ccall( - (:SCIPconshdlrGetNUpdateConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetDualfeasFrac(set, val) + ccall((:SCIPsetDualfeasFrac, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) end -function SCIPconshdlrGetSetupTime(conshdlr) - ccall( - (:SCIPconshdlrGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsLbBetter(set, newlb, oldlb, oldub) + ccall((:SCIPsetIsLbBetter, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble, Cdouble), set, newlb, oldlb, oldub) end -function SCIPconshdlrGetPresolTime(conshdlr) - ccall( - (:SCIPconshdlrGetPresolTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsUbBetter(set, newub, oldlb, oldub) + ccall((:SCIPsetIsUbBetter, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble, Cdouble), set, newub, oldlb, oldub) end -function SCIPconshdlrGetSepaTime(conshdlr) - ccall( - (:SCIPconshdlrGetSepaTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsEfficacious(set, root, efficacy) + ccall((:SCIPsetIsEfficacious, libscip), Cuint, (Ptr{SCIP_SET}, Cuint, Cdouble), set, root, efficacy) end -function SCIPconshdlrGetEnfoLPTime(conshdlr) - ccall( - (:SCIPconshdlrGetEnfoLPTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsRelEQ(set, val1, val2) + ccall((:SCIPsetIsRelEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetEnfoPSTime(conshdlr) - ccall( - (:SCIPconshdlrGetEnfoPSTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsRelLT(set, val1, val2) + ccall((:SCIPsetIsRelLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetEnfoRelaxTime(conshdlr) - ccall( - (:SCIPconshdlrGetEnfoRelaxTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsRelLE(set, val1, val2) + ccall((:SCIPsetIsRelLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetPropTime(conshdlr) - ccall( - (:SCIPconshdlrGetPropTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsRelGT(set, val1, val2) + ccall((:SCIPsetIsRelGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetStrongBranchPropTime(conshdlr) - ccall( - (:SCIPconshdlrGetStrongBranchPropTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsRelGE(set, val1, val2) + ccall((:SCIPsetIsRelGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetCheckTime(conshdlr) - ccall( - (:SCIPconshdlrGetCheckTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsSumRelEQ(set, val1, val2) + ccall((:SCIPsetIsSumRelEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetRespropTime(conshdlr) - ccall( - (:SCIPconshdlrGetRespropTime, libscip), - Cdouble, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsSumRelLT(set, val1, val2) + ccall((:SCIPsetIsSumRelLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetNSepaCalls(conshdlr) - ccall( - (:SCIPconshdlrGetNSepaCalls, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsSumRelLE(set, val1, val2) + ccall((:SCIPsetIsSumRelLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetNEnfoLPCalls(conshdlr) - ccall( - (:SCIPconshdlrGetNEnfoLPCalls, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsSumRelGT(set, val1, val2) + ccall((:SCIPsetIsSumRelGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetNEnfoPSCalls(conshdlr) - ccall( - (:SCIPconshdlrGetNEnfoPSCalls, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetIsSumRelGE(set, val1, val2) + ccall((:SCIPsetIsSumRelGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) end -function SCIPconshdlrGetNEnfoRelaxCalls(conshdlr) - ccall( - (:SCIPconshdlrGetNEnfoRelaxCalls, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsetGetSubscipsOff(set) + ccall((:SCIPsetGetSubscipsOff, libscip), Cuint, (Ptr{SCIP_SET},), set) end -function SCIPconshdlrGetNPropCalls(conshdlr) - ccall( - (:SCIPconshdlrGetNPropCalls, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreate(sol, blkmem, set, stat, primal, tree, heur) + ccall((:SCIPsolCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, heur) end -function SCIPconshdlrGetNCheckCalls(conshdlr) - ccall( - (:SCIPconshdlrGetNCheckCalls, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateExact(sol, blkmem, set, stat, primal, tree, heur) + ccall((:SCIPsolCreateExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, heur) end -function SCIPconshdlrGetNRespropCalls(conshdlr) - ccall( - (:SCIPconshdlrGetNRespropCalls, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateOriginal(sol, blkmem, set, stat, origprob, primal, tree, heur) + ccall((:SCIPsolCreateOriginal, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, origprob, primal, tree, heur) end -function SCIPconshdlrGetNCutoffs(conshdlr) - ccall( - (:SCIPconshdlrGetNCutoffs, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateOriginalExact(sol, blkmem, set, stat, origprob, primal, tree, heur) + ccall((:SCIPsolCreateOriginalExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, origprob, primal, tree, heur) end -function SCIPconshdlrGetNCutsFound(conshdlr) - ccall( - (:SCIPconshdlrGetNCutsFound, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCopy(sol, blkmem, set, stat, primal, sourcesol) + ccall((:SCIPsolCopy, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_SOL}), sol, blkmem, set, stat, primal, sourcesol) end -function SCIPconshdlrGetNCutsApplied(conshdlr) - ccall( - (:SCIPconshdlrGetNCutsApplied, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolTransform(sol, transsol, blkmem, set, primal) + ccall((:SCIPsolTransform, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PRIMAL}), sol, transsol, blkmem, set, primal) end -function SCIPconshdlrGetNConssFound(conshdlr) - ccall( - (:SCIPconshdlrGetNConssFound, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolAdjustImplicitSolVals(sol, set, stat, prob, tree, uselprows) + ccall((:SCIPsolAdjustImplicitSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Cuint), sol, set, stat, prob, tree, uselprows) end -function SCIPconshdlrGetNDomredsFound(conshdlr) - ccall( - (:SCIPconshdlrGetNDomredsFound, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateLPSol(sol, blkmem, set, stat, prob, primal, tree, lp, heur) + ccall((:SCIPsolCreateLPSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, prob, primal, tree, lp, heur) end -function SCIPconshdlrGetNChildren(conshdlr) - ccall( - (:SCIPconshdlrGetNChildren, libscip), - Clonglong, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateLPSolExact(sol, blkmem, set, stat, primal, tree, lp, heur) + ccall((:SCIPsolCreateLPSolExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, lp, heur) end -function SCIPconshdlrGetMaxNActiveConss(conshdlr) - ccall( - (:SCIPconshdlrGetMaxNActiveConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateNLPSol(sol, blkmem, set, stat, primal, tree, nlp, heur) + ccall((:SCIPsolCreateNLPSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_NLP}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, nlp, heur) end -function SCIPconshdlrGetStartNActiveConss(conshdlr) - ccall( - (:SCIPconshdlrGetStartNActiveConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateRelaxSol(sol, blkmem, set, stat, primal, tree, relaxation, heur) + ccall((:SCIPsolCreateRelaxSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, relaxation, heur) end -function SCIPconshdlrGetNFixedVars(conshdlr) - ccall( - (:SCIPconshdlrGetNFixedVars, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreatePseudoSol(sol, blkmem, set, stat, prob, primal, tree, lp, heur) + ccall((:SCIPsolCreatePseudoSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, prob, primal, tree, lp, heur) end -function SCIPconshdlrGetNAggrVars(conshdlr) - ccall( - (:SCIPconshdlrGetNAggrVars, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreatePseudoSolExact(sol, blkmem, set, stat, primal, tree, lp, heur) + ccall((:SCIPsolCreatePseudoSolExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, lp, heur) end -function SCIPconshdlrGetNChgVarTypes(conshdlr) - ccall( - (:SCIPconshdlrGetNChgVarTypes, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateCurrentSol(sol, blkmem, set, stat, prob, primal, tree, lp, heur) + ccall((:SCIPsolCreateCurrentSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, prob, primal, tree, lp, heur) end -function SCIPconshdlrGetNChgBds(conshdlr) - ccall( - (:SCIPconshdlrGetNChgBds, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateCurrentSolExact(sol, blkmem, set, stat, primal, tree, lp, heur) + ccall((:SCIPsolCreateCurrentSolExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, lp, heur) end -function SCIPconshdlrGetNAddHoles(conshdlr) - ccall( - (:SCIPconshdlrGetNAddHoles, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreatePartial(sol, blkmem, set, stat, primal, heur) + ccall((:SCIPsolCreatePartial, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, heur) end -function SCIPconshdlrGetNDelConss(conshdlr) - ccall( - (:SCIPconshdlrGetNDelConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCreateUnknown(sol, blkmem, set, stat, primal, tree, heur) + ccall((:SCIPsolCreateUnknown, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, heur) end -function SCIPconshdlrGetNAddConss(conshdlr) - ccall( - (:SCIPconshdlrGetNAddConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolFree(sol, blkmem, primal) + ccall((:SCIPsolFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_PRIMAL}), sol, blkmem, primal) end -function SCIPconshdlrGetNUpgdConss(conshdlr) - ccall( - (:SCIPconshdlrGetNUpgdConss, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolLinkLPSol(sol, set, stat, prob, tree, lp) + ccall((:SCIPsolLinkLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), sol, set, stat, prob, tree, lp) end -function SCIPconshdlrGetNChgCoefs(conshdlr) - ccall( - (:SCIPconshdlrGetNChgCoefs, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolLinkLPSolExact(sol, set, lp) + ccall((:SCIPsolLinkLPSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), sol, set, lp) end -function SCIPconshdlrGetNChgSides(conshdlr) - ccall( - (:SCIPconshdlrGetNChgSides, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolLinkNLPSol(sol, stat, tree, nlp) + ccall((:SCIPsolLinkNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_NLP}), sol, stat, tree, nlp) end -function SCIPconshdlrGetNPresolCalls(conshdlr) - ccall( - (:SCIPconshdlrGetNPresolCalls, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolLinkRelaxSol(sol, set, stat, tree, relaxation) + ccall((:SCIPsolLinkRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_RELAXATION}), sol, set, stat, tree, relaxation) end -function SCIPconshdlrGetSepaPriority(conshdlr) - ccall( - (:SCIPconshdlrGetSepaPriority, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolLinkPseudoSol(sol, set, stat, prob, tree, lp) + ccall((:SCIPsolLinkPseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), sol, set, stat, prob, tree, lp) end -function SCIPconshdlrGetEnfoPriority(conshdlr) - ccall( - (:SCIPconshdlrGetEnfoPriority, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolLinkPseudoSolExact(sol, set, lp) + ccall((:SCIPsolLinkPseudoSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), sol, set, lp) end -function SCIPconshdlrGetCheckPriority(conshdlr) - ccall( - (:SCIPconshdlrGetCheckPriority, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolLinkCurrentSol(sol, set, stat, prob, tree, lp) + ccall((:SCIPsolLinkCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), sol, set, stat, prob, tree, lp) end -function SCIPconshdlrGetSepaFreq(conshdlr) - ccall( - (:SCIPconshdlrGetSepaFreq, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolClear(sol, stat, tree) + ccall((:SCIPsolClear, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), sol, stat, tree) end -function SCIPconshdlrGetPropFreq(conshdlr) - ccall( - (:SCIPconshdlrGetPropFreq, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolSetUnknown(sol, stat, tree) + ccall((:SCIPsolSetUnknown, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), sol, stat, tree) end -function SCIPconshdlrGetEagerFreq(conshdlr) - ccall( - (:SCIPconshdlrGetEagerFreq, libscip), - Cint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolUnlink(sol, set, prob) + ccall((:SCIPsolUnlink, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), sol, set, prob) end -function SCIPconshdlrNeedsCons(conshdlr) - ccall( - (:SCIPconshdlrNeedsCons, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolUnlinkExact(sol, set, prob) + ccall((:SCIPsolUnlinkExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), sol, set, prob) end -function SCIPconshdlrDoesPresolve(conshdlr) - ccall( - (:SCIPconshdlrDoesPresolve, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolSetVal(sol, set, stat, tree, var, val) + ccall((:SCIPsolSetVal, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_VAR}, Cdouble), sol, set, stat, tree, var, val) end -function SCIPconshdlrIsSeparationDelayed(conshdlr) - ccall( - (:SCIPconshdlrIsSeparationDelayed, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolSetValExact(sol, set, stat, tree, var, val) + ccall((:SCIPsolSetValExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), sol, set, stat, tree, var, val) end -function SCIPconshdlrIsPropagationDelayed(conshdlr) - ccall( - (:SCIPconshdlrIsPropagationDelayed, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolIncVal(sol, set, stat, tree, var, incval) + ccall((:SCIPsolIncVal, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_VAR}, Cdouble), sol, set, stat, tree, var, incval) end -function SCIPconshdlrWasLPSeparationDelayed(conshdlr) - ccall( - (:SCIPconshdlrWasLPSeparationDelayed, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolGetVal(sol, set, stat, var) + ccall((:SCIPsolGetVal, libscip), Cdouble, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}), sol, set, stat, var) end -function SCIPconshdlrWasSolSeparationDelayed(conshdlr) - ccall( - (:SCIPconshdlrWasSolSeparationDelayed, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolGetValExact(res, sol, set, stat, var) + ccall((:SCIPsolGetValExact, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}), res, sol, set, stat, var) end -function SCIPconshdlrWasPropagationDelayed(conshdlr) - ccall( - (:SCIPconshdlrWasPropagationDelayed, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolGetRayVal(sol, set, stat, var) + ccall((:SCIPsolGetRayVal, libscip), Cdouble, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}), sol, set, stat, var) end -function SCIPconshdlrIsInitialized(conshdlr) - ccall( - (:SCIPconshdlrIsInitialized, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolGetObj(sol, set, transprob, origprob) + ccall((:SCIPsolGetObj, libscip), Cdouble, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}), sol, set, transprob, origprob) end -function SCIPconshdlrIsClonable(conshdlr) - ccall( - (:SCIPconshdlrIsClonable, libscip), - Cuint, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolGetObjExact(sol, set, transprob, origprob, objval) + ccall((:SCIPsolGetObjExact, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_RATIONAL}), sol, set, transprob, origprob, objval) end -function SCIPconshdlrGetPropTiming(conshdlr) - ccall( - (:SCIPconshdlrGetPropTiming, libscip), - SCIP_PROPTIMING, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolUpdateVarObj(sol, var, oldobj, newobj) + ccall((:SCIPsolUpdateVarObj, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble, Cdouble), sol, var, oldobj, newobj) end -function SCIPconssetchgGetAddedConsData(conssetchg, conss, nconss) - ccall( - (:SCIPconssetchgGetAddedConsData, libscip), - Cvoid, - (Ptr{SCIP_CONSSETCHG}, Ptr{Ptr{Ptr{SCIP_CONS}}}, Ptr{Cint}), - conssetchg, - conss, - nconss, - ) +function SCIPsolMarkPartial(sol, set, stat, vars, nvars) + ccall((:SCIPsolMarkPartial, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Ptr{SCIP_VAR}}, Cint), sol, set, stat, vars, nvars) end -function SCIPconshdlrSetPropTiming(conshdlr, proptiming) - ccall( - (:SCIPconshdlrSetPropTiming, libscip), - Cvoid, - (Ptr{SCIP_CONSHDLR}, SCIP_PROPTIMING), - conshdlr, - proptiming, - ) +function SCIPsolCheckOrig(sol, set, messagehdlr, blkmem, stat, prob, primal, printreason, completely, checkbounds, checkintegrality, checklprows, checkmodifiable, feasible) + ccall((:SCIPsolCheckOrig, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sol, set, messagehdlr, blkmem, stat, prob, primal, printreason, completely, checkbounds, checkintegrality, checklprows, checkmodifiable, feasible) end -function SCIPconshdlrGetPresolTiming(conshdlr) - ccall( - (:SCIPconshdlrGetPresolTiming, libscip), - SCIP_PRESOLTIMING, - (Ptr{SCIP_CONSHDLR},), - conshdlr, - ) +function SCIPsolCheck(sol, set, messagehdlr, blkmem, stat, prob, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) + ccall((:SCIPsolCheck, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sol, set, messagehdlr, blkmem, stat, prob, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) end -function SCIPconshdlrSetPresolTiming(conshdlr, presoltiming) - ccall( - (:SCIPconshdlrSetPresolTiming, libscip), - Cvoid, - (Ptr{SCIP_CONSHDLR}, SCIP_PRESOLTIMING), - conshdlr, - presoltiming, - ) +function SCIPsolRound(sol, set, stat, prob, tree, success) + ccall((:SCIPsolRound, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{Cuint}), sol, set, stat, prob, tree, success) end -function SCIPconsGetName(cons) - ccall((:SCIPconsGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_CONS},), cons) +function SCIPsolMakeExact(sol, blkmem, set, stat, prob) + ccall((:SCIPsolMakeExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), sol, blkmem, set, stat, prob) end -function SCIPconsGetPos(cons) - ccall((:SCIPconsGetPos, libscip), Cint, (Ptr{SCIP_CONS},), cons) +function SCIPsolMakeReal(sol, blkmem, set, stat, prob) + ccall((:SCIPsolMakeReal, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), sol, blkmem, set, stat, prob) end -function SCIPconsGetHdlr(cons) - ccall( - (:SCIPconsGetHdlr, libscip), - Ptr{SCIP_CONSHDLR}, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPsolUpdateVarsum(sol, set, stat, prob, weight) + ccall((:SCIPsolUpdateVarsum, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Cdouble), sol, set, stat, prob, weight) end -function SCIPconsGetData(cons) - ccall( - (:SCIPconsGetData, libscip), - Ptr{SCIP_CONSDATA}, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPsolRetransform(sol, set, stat, origprob, transprob, hasinfval) + ccall((:SCIPsolRetransform, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Cuint}), sol, set, stat, origprob, transprob, hasinfval) end -function SCIPconsGetNUses(cons) - ccall((:SCIPconsGetNUses, libscip), Cint, (Ptr{SCIP_CONS},), cons) +function SCIPsolRetransformExact(sol, set, stat, origprob, transprob, hasinfval) + ccall((:SCIPsolRetransformExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Cuint}), sol, set, stat, origprob, transprob, hasinfval) end -function SCIPconsGetActiveDepth(cons) - ccall((:SCIPconsGetActiveDepth, libscip), Cint, (Ptr{SCIP_CONS},), cons) +function SCIPsolRecomputeObj(sol, set, stat, origprob) + ccall((:SCIPsolRecomputeObj, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), sol, set, stat, origprob) end -function SCIPconsGetValidDepth(cons) - ccall((:SCIPconsGetValidDepth, libscip), Cint, (Ptr{SCIP_CONS},), cons) +function SCIPsolRecomputeInternObjExact(sol, set, stat, prob) + ccall((:SCIPsolRecomputeInternObjExact, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), sol, set, stat, prob) end -function SCIPconsIsActive(cons) - ccall((:SCIPconsIsActive, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolsAreEqual(sol1, sol2, set, stat, origprob, transprob) + ccall((:SCIPsolsAreEqual, libscip), Cuint, (Ptr{SCIP_SOL}, Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}), sol1, sol2, set, stat, origprob, transprob) end -function SCIPconsIsUpdatedeactivate(cons) - ccall( - (:SCIPconsIsUpdatedeactivate, libscip), - Cuint, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPsolPrint(sol, set, messagehdlr, stat, prob, transprob, file, mipstart, printzeros) + ccall((:SCIPsolPrint, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Libc.FILE}, Cuint, Cuint), sol, set, messagehdlr, stat, prob, transprob, file, mipstart, printzeros) end -function SCIPconsIsEnabled(cons) - ccall((:SCIPconsIsEnabled, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolPrintExact(sol, set, messagehdlr, stat, prob, transprob, file, mipstart, printzeros) + ccall((:SCIPsolPrintExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Libc.FILE}, Cuint, Cuint), sol, set, messagehdlr, stat, prob, transprob, file, mipstart, printzeros) end -function SCIPconsIsSeparationEnabled(cons) - ccall( - (:SCIPconsIsSeparationEnabled, libscip), - Cuint, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPsolPrintRay(sol, set, messagehdlr, stat, prob, transprob, file, printzeros) + ccall((:SCIPsolPrintRay, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Libc.FILE}, Cuint), sol, set, messagehdlr, stat, prob, transprob, file, printzeros) end -function SCIPconsIsPropagationEnabled(cons) - ccall( - (:SCIPconsIsPropagationEnabled, libscip), - Cuint, - (Ptr{SCIP_CONS},), - cons, - ) +function SCIPsolSetOrigin(sol, origin) + ccall((:SCIPsolSetOrigin, libscip), Cvoid, (Ptr{SCIP_SOL}, SCIP_SOLORIGIN), sol, origin) end -function SCIPconsIsDeleted(cons) - ccall((:SCIPconsIsDeleted, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolResetViolations(sol) + ccall((:SCIPsolResetViolations, libscip), Cvoid, (Ptr{SCIP_SOL},), sol) end -function SCIPconsIsObsolete(cons) - ccall((:SCIPconsIsObsolete, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolUpdateIntegralityViolation(sol, absviolintegrality) + ccall((:SCIPsolUpdateIntegralityViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble), sol, absviolintegrality) end -function SCIPconsIsConflict(cons) - ccall((:SCIPconsIsConflict, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolUpdateBoundViolation(sol, absviolbounds, relviolbounds) + ccall((:SCIPsolUpdateBoundViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble, Cdouble), sol, absviolbounds, relviolbounds) end -function SCIPconsGetAge(cons) - ccall((:SCIPconsGetAge, libscip), Cdouble, (Ptr{SCIP_CONS},), cons) +function SCIPsolUpdateLPRowViolation(sol, absviollprows, relviollprows) + ccall((:SCIPsolUpdateLPRowViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble, Cdouble), sol, absviollprows, relviollprows) end -function SCIPconsIsInitial(cons) - ccall((:SCIPconsIsInitial, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolUpdateConsViolation(sol, absviolcons, relviolcons) + ccall((:SCIPsolUpdateConsViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble, Cdouble), sol, absviolcons, relviolcons) end -function SCIPconsIsSeparated(cons) - ccall((:SCIPconsIsSeparated, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolUpdateLPConsViolation(sol, absviol, relviol) + ccall((:SCIPsolUpdateLPConsViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble, Cdouble), sol, absviol, relviol) end -function SCIPconsIsEnforced(cons) - ccall((:SCIPconsIsEnforced, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolGetOrigObjExact(sol) + ccall((:SCIPsolGetOrigObjExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_SOL},), sol) end -function SCIPconsIsChecked(cons) - ccall((:SCIPconsIsChecked, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolOverwriteFPSolWithExact(sol, set, stat, origprob, transprob, tree) + ccall((:SCIPsolOverwriteFPSolWithExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}), sol, set, stat, origprob, transprob, tree) end -function SCIPconsIsMarkedPropagate(cons) - ccall((:SCIPconsIsMarkedPropagate, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPvalsExactCopy(valsexact, blkmem, sourcevals) + ccall((:SCIPvalsExactCopy, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VALSEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_VALSEXACT}), valsexact, blkmem, sourcevals) end -function SCIPconsIsPropagated(cons) - ccall((:SCIPconsIsPropagated, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolOrigAddObjval(sol, addval) + ccall((:SCIPsolOrigAddObjval, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble), sol, addval) end -function SCIPconsIsGlobal(cons) - ccall((:SCIPconsIsGlobal, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolGetPrimalIndex(sol) + ccall((:SCIPsolGetPrimalIndex, libscip), Cint, (Ptr{SCIP_SOL},), sol) end -function SCIPconsIsLocal(cons) - ccall((:SCIPconsIsLocal, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPsolSetPrimalIndex(sol, primalindex) + ccall((:SCIPsolSetPrimalIndex, libscip), Cvoid, (Ptr{SCIP_SOL}, Cint), sol, primalindex) end -function SCIPconsIsModifiable(cons) - ccall((:SCIPconsIsModifiable, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqCreate(nodepq, set, nodesel) + ccall((:SCIPnodepqCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODEPQ}}, Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), nodepq, set, nodesel) end -function SCIPconsIsDynamic(cons) - ccall((:SCIPconsIsDynamic, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqDestroy(nodepq) + ccall((:SCIPnodepqDestroy, libscip), Cvoid, (Ptr{Ptr{SCIP_NODEPQ}},), nodepq) end -function SCIPconsIsRemovable(cons) - ccall((:SCIPconsIsRemovable, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqFree(nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, lp) + ccall((:SCIPnodepqFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODEPQ}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, lp) end -function SCIPconsIsStickingAtNode(cons) - ccall((:SCIPconsIsStickingAtNode, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqClear(nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, lp) + ccall((:SCIPnodepqClear, libscip), SCIP_RETCODE, (Ptr{SCIP_NODEPQ}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, lp) end -function SCIPconsIsInProb(cons) - ccall((:SCIPconsIsInProb, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqGetNodesel(nodepq) + ccall((:SCIPnodepqGetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_NODEPQ},), nodepq) end -function SCIPconsIsOriginal(cons) - ccall((:SCIPconsIsOriginal, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqSetNodesel(nodepq, set, nodesel) + ccall((:SCIPnodepqSetNodesel, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODEPQ}}, Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), nodepq, set, nodesel) end -function SCIPconsIsTransformed(cons) - ccall((:SCIPconsIsTransformed, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqCompare(nodepq, set, node1, node2) + ccall((:SCIPnodepqCompare, libscip), Cint, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), nodepq, set, node1, node2) end -function SCIPconsIsLockedPos(cons) - ccall((:SCIPconsIsLockedPos, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqInsert(nodepq, set, node) + ccall((:SCIPnodepqInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}), nodepq, set, node) end -function SCIPconsIsLockedNeg(cons) - ccall((:SCIPconsIsLockedNeg, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqRemove(nodepq, set, node) + ccall((:SCIPnodepqRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}), nodepq, set, node) end -function SCIPconsIsLocked(cons) - ccall((:SCIPconsIsLocked, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqFirst(nodepq) + ccall((:SCIPnodepqFirst, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_NODEPQ},), nodepq) end -function SCIPconsGetNLocksPos(cons) - ccall((:SCIPconsGetNLocksPos, libscip), Cint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqNodes(nodepq) + ccall((:SCIPnodepqNodes, libscip), Ptr{Ptr{SCIP_NODE}}, (Ptr{SCIP_NODEPQ},), nodepq) end -function SCIPconsGetNLocksNeg(cons) - ccall((:SCIPconsGetNLocksNeg, libscip), Cint, (Ptr{SCIP_CONS},), cons) +function SCIPnodepqLen(nodepq) + ccall((:SCIPnodepqLen, libscip), Cint, (Ptr{SCIP_NODEPQ},), nodepq) end -function SCIPconsIsLockedTypePos(cons, locktype) - ccall( - (:SCIPconsIsLockedTypePos, libscip), - Cuint, - (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), - cons, - locktype, - ) +function SCIPnodepqGetLowerbound(nodepq, set) + ccall((:SCIPnodepqGetLowerbound, libscip), Cdouble, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), nodepq, set) end -function SCIPconsIsLockedTypeNeg(cons, locktype) - ccall( - (:SCIPconsIsLockedTypeNeg, libscip), - Cuint, - (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), - cons, - locktype, - ) +function SCIPnodepqGetLowerboundExact(nodepq, set) + ccall((:SCIPnodepqGetLowerboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), nodepq, set) end -function SCIPconsIsLockedType(cons, locktype) - ccall( - (:SCIPconsIsLockedType, libscip), - Cuint, - (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), - cons, - locktype, - ) +function SCIPnodepqGetLowerboundNode(nodepq, set) + ccall((:SCIPnodepqGetLowerboundNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), nodepq, set) end -function SCIPconsGetNLocksTypePos(cons, locktype) - ccall( - (:SCIPconsGetNLocksTypePos, libscip), - Cint, - (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), - cons, - locktype, - ) +function SCIPnodepqGetLowerboundSum(nodepq) + ccall((:SCIPnodepqGetLowerboundSum, libscip), Cdouble, (Ptr{SCIP_NODEPQ},), nodepq) end -function SCIPconsGetNLocksTypeNeg(cons, locktype) - ccall( - (:SCIPconsGetNLocksTypeNeg, libscip), - Cint, - (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), - cons, - locktype, - ) +function SCIPnodepqBound(nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, reopt, lp, cutoffbound) + ccall((:SCIPnodepqBound, libscip), SCIP_RETCODE, (Ptr{SCIP_NODEPQ}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Cdouble), nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, reopt, lp, cutoffbound) end -function SCIPconsIsAdded(cons) - ccall((:SCIPconsIsAdded, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +function SCIPnodeselCopyInclude(nodesel, set) + ccall((:SCIPnodeselCopyInclude, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) end -function SCIPconsAddUpgradeLocks(cons, nlocks) - ccall( - (:SCIPconsAddUpgradeLocks, libscip), - Cvoid, - (Ptr{SCIP_CONS}, Cint), - cons, - nlocks, - ) +function SCIPnodeselCreate(nodesel, set, messagehdlr, blkmem, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) + ccall((:SCIPnodeselCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODESEL}}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), nodesel, set, messagehdlr, blkmem, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) end -function SCIPconsGetNUpgradeLocks(cons) - ccall((:SCIPconsGetNUpgradeLocks, libscip), Cint, (Ptr{SCIP_CONS},), cons) +function SCIPnodeselFree(nodesel, set) + ccall((:SCIPnodeselFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODESEL}}, Ptr{SCIP_SET}), nodesel, set) end -function SCIPlinConsStatsCreate(scip, linconsstats) - ccall( - (:SCIPlinConsStatsCreate, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_LINCONSSTATS}}), - scip, - linconsstats, - ) +function SCIPnodeselInit(nodesel, set) + ccall((:SCIPnodeselInit, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) end -function SCIPlinConsStatsFree(scip, linconsstats) - ccall( - (:SCIPlinConsStatsFree, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{SCIP_LINCONSSTATS}}), - scip, - linconsstats, - ) +function SCIPnodeselExit(nodesel, set) + ccall((:SCIPnodeselExit, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) end -function SCIPlinConsStatsReset(linconsstats) - ccall( - (:SCIPlinConsStatsReset, libscip), - Cvoid, - (Ptr{SCIP_LINCONSSTATS},), - linconsstats, - ) +function SCIPnodeselInitsol(nodesel, set) + ccall((:SCIPnodeselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) end -function SCIPlinConsStatsGetTypeCount(linconsstats, linconstype) - ccall( - (:SCIPlinConsStatsGetTypeCount, libscip), - Cint, - (Ptr{SCIP_LINCONSSTATS}, SCIP_LINCONSTYPE), - linconsstats, - linconstype, - ) +function SCIPnodeselExitsol(nodesel, set) + ccall((:SCIPnodeselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) end -function SCIPlinConsStatsGetSum(linconsstats) - ccall( - (:SCIPlinConsStatsGetSum, libscip), - Cint, - (Ptr{SCIP_LINCONSSTATS},), - linconsstats, - ) +function SCIPnodeselSelect(nodesel, set, selnode) + ccall((:SCIPnodeselSelect, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Ptr{Ptr{SCIP_NODE}}), nodesel, set, selnode) end -function SCIPlinConsStatsIncTypeCount(linconsstats, linconstype, increment) - ccall( - (:SCIPlinConsStatsIncTypeCount, libscip), - Cvoid, - (Ptr{SCIP_LINCONSSTATS}, SCIP_LINCONSTYPE, Cint), - linconsstats, - linconstype, - increment, - ) +function SCIPnodeselCompare(nodesel, set, node1, node2) + ccall((:SCIPnodeselCompare, libscip), Cint, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), nodesel, set, node1, node2) end -function SCIPprintLinConsStats(scip, file, linconsstats) - ccall( - (:SCIPprintLinConsStats, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_LINCONSSTATS}), - scip, - file, - linconsstats, - ) +function SCIPnodeselSetStdPriority(nodesel, set, priority) + ccall((:SCIPnodeselSetStdPriority, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Cint), nodesel, set, priority) end -function SCIPcutGetRow(cut) - ccall((:SCIPcutGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_CUT},), cut) +function SCIPnodeselSetMemsavePriority(nodesel, set, priority) + ccall((:SCIPnodeselSetMemsavePriority, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Cint), nodesel, set, priority) end -function SCIPcutGetAge(cut) - ccall((:SCIPcutGetAge, libscip), Cint, (Ptr{SCIP_CUT},), cut) +function SCIPnodeselSetCopy(nodesel, nodeselcopy) + ccall((:SCIPnodeselSetCopy, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselcopy) end -function SCIPcutGetLPActivityQuot(cut) - ccall((:SCIPcutGetLPActivityQuot, libscip), Cdouble, (Ptr{SCIP_CUT},), cut) +function SCIPnodeselSetFree(nodesel, nodeselfree) + ccall((:SCIPnodeselSetFree, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselfree) end -function SCIPcutpoolGetCuts(cutpool) - ccall( - (:SCIPcutpoolGetCuts, libscip), - Ptr{Ptr{SCIP_CUT}}, - (Ptr{SCIP_CUTPOOL},), - cutpool, - ) +function SCIPnodeselSetInit(nodesel, nodeselinit) + ccall((:SCIPnodeselSetInit, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselinit) end -function SCIPcutpoolGetNCuts(cutpool) - ccall((:SCIPcutpoolGetNCuts, libscip), Cint, (Ptr{SCIP_CUTPOOL},), cutpool) +function SCIPnodeselSetExit(nodesel, nodeselexit) + ccall((:SCIPnodeselSetExit, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselexit) end -function SCIPcutpoolGetMaxNCuts(cutpool) - ccall( - (:SCIPcutpoolGetMaxNCuts, libscip), - Cint, - (Ptr{SCIP_CUTPOOL},), - cutpool, - ) +function SCIPnodeselSetInitsol(nodesel, nodeselinitsol) + ccall((:SCIPnodeselSetInitsol, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselinitsol) end -function SCIPcutpoolGetTime(cutpool) - ccall( - (:SCIPcutpoolGetTime, libscip), - Cdouble, - (Ptr{SCIP_CUTPOOL},), - cutpool, - ) +function SCIPnodeselSetExitsol(nodesel, nodeselexitsol) + ccall((:SCIPnodeselSetExitsol, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselexitsol) end -function SCIPcutpoolGetNCalls(cutpool) - ccall( - (:SCIPcutpoolGetNCalls, libscip), - Clonglong, - (Ptr{SCIP_CUTPOOL},), - cutpool, - ) +function SCIPnodeselEnableOrDisableClocks(nodesel, enable) + ccall((:SCIPnodeselEnableOrDisableClocks, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Cuint), nodesel, enable) end -function SCIPcutpoolGetNCutsFound(cutpool) - ccall( - (:SCIPcutpoolGetNCutsFound, libscip), - Clonglong, - (Ptr{SCIP_CUTPOOL},), - cutpool, - ) +function SCIPnodeCreateChild(node, blkmem, set, stat, tree, nodeselprio, estimate) + ccall((:SCIPnodeCreateChild, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Cdouble, Cdouble), node, blkmem, set, stat, tree, nodeselprio, estimate) end -function SCIPcutselGetName(cutsel) - ccall( - (:SCIPcutselGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_CUTSEL},), - cutsel, - ) +function SCIPnodeFree(node, blkmem, set, stat, eventqueue, eventfilter, tree, lp) + ccall((:SCIPnodeFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), node, blkmem, set, stat, eventqueue, eventfilter, tree, lp) end -function SCIPcutselGetData(cutsel) - ccall( - (:SCIPcutselGetData, libscip), - Ptr{SCIP_CUTSELDATA}, - (Ptr{SCIP_CUTSEL},), - cutsel, - ) +function SCIPnodeCaptureLPIState(node, nuses) + ccall((:SCIPnodeCaptureLPIState, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Cint), node, nuses) end -function SCIPcutselGetDesc(cutsel) - ccall( - (:SCIPcutselGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_CUTSEL},), - cutsel, - ) +function SCIPnodeReleaseLPIState(node, blkmem, lp) + ccall((:SCIPnodeReleaseLPIState, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}), node, blkmem, lp) end -function SCIPcutselGetPriority(cutsel) - ccall((:SCIPcutselGetPriority, libscip), Cint, (Ptr{SCIP_CUTSEL},), cutsel) +function SCIPnodeFocus(node, blkmem, set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable, cutoff, postponed, exitsolve) + ccall((:SCIPnodeFocus, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_CONFLICT}, Ptr{SCIP_CONFLICTSTORE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{Cuint}, Cuint, Cuint), node, blkmem, set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable, cutoff, postponed, exitsolve) end -function SCIPcutselSetData(cutsel, cutseldata) - ccall( - (:SCIPcutselSetData, libscip), - Cvoid, - (Ptr{SCIP_CUTSEL}, Ptr{SCIP_CUTSELDATA}), - cutsel, - cutseldata, - ) +function SCIPnodeCutoff(node, set, stat, eventfilter, tree, transprob, origprob, reopt, lp, blkmem) + ccall((:SCIPnodeCutoff, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}), node, set, stat, eventfilter, tree, transprob, origprob, reopt, lp, blkmem) end -function SCIPcutselIsInitialized(cutsel) - ccall( - (:SCIPcutselIsInitialized, libscip), - Cuint, - (Ptr{SCIP_CUTSEL},), - cutsel, - ) +function SCIPnodePropagateAgain(node, set, stat, tree) + ccall((:SCIPnodePropagateAgain, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), node, set, stat, tree) end -function SCIPcutselGetSetupTime(cutsel) - ccall( - (:SCIPcutselGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_CUTSEL},), - cutsel, - ) +function SCIPnodeMarkPropagated(node, tree) + ccall((:SCIPnodeMarkPropagated, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{SCIP_TREE}), node, tree) end -function SCIPcutselGetTime(cutsel) - ccall((:SCIPcutselGetTime, libscip), Cdouble, (Ptr{SCIP_CUTSEL},), cutsel) +function SCIPnodeAddCons(node, blkmem, set, stat, tree, cons) + ccall((:SCIPnodeAddCons, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_CONS}), node, blkmem, set, stat, tree, cons) end -function SCIPcutselComp(elem1, elem2) - ccall( - (:SCIPcutselComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +function SCIPnodeDelCons(node, blkmem, set, stat, tree, cons) + ccall((:SCIPnodeDelCons, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_CONS}), node, blkmem, set, stat, tree, cons) end -function SCIPdecompCreate(decomp, blkmem, nblocks, original, benderslabels) - ccall( - (:SCIPdecompCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_DECOMP}}, Ptr{BMS_BLKMEM}, Cint, Cuint, Cuint), - decomp, - blkmem, - nblocks, - original, - benderslabels, - ) +function SCIPnodeGetPropsBeforeDual(node, vars, varbounds, varboundtypes, npropvars, propvarssize) + ccall((:SCIPnodeGetPropsBeforeDual, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, vars, varbounds, varboundtypes, npropvars, propvarssize) end -function SCIPdecompFree(decomp, blkmem) - ccall( - (:SCIPdecompFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_DECOMP}}, Ptr{BMS_BLKMEM}), - decomp, - blkmem, - ) +function SCIPnodeGetPropsAfterDual(node, vars, varbounds, varboundtypes, nvars, varssize) + ccall((:SCIPnodeGetPropsAfterDual, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, vars, varbounds, varboundtypes, nvars, varssize) end -function SCIPdecompIsOriginal(decomp) - ccall((:SCIPdecompIsOriginal, libscip), Cuint, (Ptr{SCIP_DECOMP},), decomp) +function SCIPnodeAddBoundinfer(node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, infercons, inferprop, inferinfo, probingchange) + ccall((:SCIPnodeAddBoundinfer, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{SCIP_VAR}, Cdouble, SCIP_BOUNDTYPE, Ptr{SCIP_CONS}, Ptr{SCIP_PROP}, Cint, Cuint), node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, infercons, inferprop, inferinfo, probingchange) end -function SCIPdecompSetUseBendersLabels(decomp, benderslabels) - ccall( - (:SCIPdecompSetUseBendersLabels, libscip), - Cvoid, - (Ptr{SCIP_DECOMP}, Cuint), - decomp, - benderslabels, - ) +function SCIPnodeAddBoundinferExact(node, blkmem, set, stat, transprob, origprob, tree, reopt, lpexact, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, infercons, inferprop, inferinfo, probingchange) + ccall((:SCIPnodeAddBoundinferExact, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, SCIP_BOUNDTYPE, Ptr{SCIP_CONS}, Ptr{SCIP_PROP}, Cint, Cuint), node, blkmem, set, stat, transprob, origprob, tree, reopt, lpexact, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, infercons, inferprop, inferinfo, probingchange) end -function SCIPdecompUseBendersLabels(decomp) - ccall( - (:SCIPdecompUseBendersLabels, libscip), - Cuint, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPnodeAddBoundchg(node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, probingchange) + ccall((:SCIPnodeAddBoundchg, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{SCIP_VAR}, Cdouble, SCIP_BOUNDTYPE, Cuint), node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, probingchange) end -function SCIPdecompGetNBlocks(decomp) - ccall((:SCIPdecompGetNBlocks, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +function SCIPnodeAddBoundchgExact(node, blkmem, set, stat, transprob, origprob, tree, reopt, lpexact, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, probingchange) + ccall((:SCIPnodeAddBoundchgExact, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, SCIP_BOUNDTYPE, Cuint), node, blkmem, set, stat, transprob, origprob, tree, reopt, lpexact, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, probingchange) end -function SCIPdecompGetAreaScore(decomp) - ccall( - (:SCIPdecompGetAreaScore, libscip), - Cdouble, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPnodeAddHoleinfer(node, blkmem, set, stat, tree, eventqueue, var, left, right, infercons, inferprop, inferinfo, probingchange, added) + ccall((:SCIPnodeAddHoleinfer, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{SCIP_CONS}, Ptr{SCIP_PROP}, Cint, Cuint, Ptr{Cuint}), node, blkmem, set, stat, tree, eventqueue, var, left, right, infercons, inferprop, inferinfo, probingchange, added) end -function SCIPdecompGetModularity(decomp) - ccall( - (:SCIPdecompGetModularity, libscip), - Cdouble, - (Ptr{SCIP_DECOMP},), - decomp, - ) -end - -function SCIPdecompGetVarsSize(decomp, varssize, nblocks) - ccall( - (:SCIPdecompGetVarsSize, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DECOMP}, Ptr{Cint}, Cint), - decomp, - varssize, - nblocks, - ) -end - -function SCIPdecompGetConssSize(decomp, consssize, nblocks) - ccall( - (:SCIPdecompGetConssSize, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DECOMP}, Ptr{Cint}, Cint), - decomp, - consssize, - nblocks, - ) +function SCIPnodeAddHolechg(node, blkmem, set, stat, tree, eventqueue, var, left, right, probingchange, added) + ccall((:SCIPnodeAddHolechg, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cuint, Ptr{Cuint}), node, blkmem, set, stat, tree, eventqueue, var, left, right, probingchange, added) end -function SCIPdecompGetNBorderVars(decomp) - ccall( - (:SCIPdecompGetNBorderVars, libscip), - Cint, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPnodeUpdateLowerbound(node, stat, set, eventfilter, tree, transprob, origprob, newbound, newboundexact) + ccall((:SCIPnodeUpdateLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{SCIP_STAT}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Cdouble, Ptr{SCIP_RATIONAL}), node, stat, set, eventfilter, tree, transprob, origprob, newbound, newboundexact) end -function SCIPdecompGetNBorderConss(decomp) - ccall( - (:SCIPdecompGetNBorderConss, libscip), - Cint, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPnodeUpdateLowerboundLP(node, set, stat, messagehdlr, eventfilter, tree, transprob, origprob, lp) + ccall((:SCIPnodeUpdateLowerboundLP, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}), node, set, stat, messagehdlr, eventfilter, tree, transprob, origprob, lp) end -function SCIPdecompGetNBlockGraphEdges(decomp) - ccall( - (:SCIPdecompGetNBlockGraphEdges, libscip), - Cint, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPchildChgNodeselPrio(tree, child, priority) + ccall((:SCIPchildChgNodeselPrio, libscip), Cvoid, (Ptr{SCIP_TREE}, Ptr{SCIP_NODE}, Cdouble), tree, child, priority) end -function SCIPdecompGetNBlockGraphComponents(decomp) - ccall( - (:SCIPdecompGetNBlockGraphComponents, libscip), - Cint, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPnodeSetEstimate(node, set, newestimate) + ccall((:SCIPnodeSetEstimate, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Cdouble), node, set, newestimate) end -function SCIPdecompGetNBlockGraphArticulations(decomp) - ccall( - (:SCIPdecompGetNBlockGraphArticulations, libscip), - Cint, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPnodePropagateImplics(node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, cutoff) + ccall((:SCIPnodePropagateImplics, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{Cuint}), node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, cutoff) end -function SCIPdecompGetBlockGraphMaxDegree(decomp) - ccall( - (:SCIPdecompGetBlockGraphMaxDegree, libscip), - Cint, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPnodeGetDualBoundchgs(node, vars, bounds, boundtypes, nvars, varssize) + ccall((:SCIPnodeGetDualBoundchgs, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, vars, bounds, boundtypes, nvars, varssize) end -function SCIPdecompGetBlockGraphMinDegree(decomp) - ccall( - (:SCIPdecompGetBlockGraphMinDegree, libscip), - Cint, - (Ptr{SCIP_DECOMP},), - decomp, - ) +function SCIPnodeGetNDualBndchgs(node) + ccall((:SCIPnodeGetNDualBndchgs, libscip), Cint, (Ptr{SCIP_NODE},), node) end -function SCIPdecompSetVarsLabels(decomp, vars, labels, nvars) - ccall( - (:SCIPdecompSetVarsLabels, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), - decomp, - vars, - labels, - nvars, - ) +function SCIPtreeCreate(tree, blkmem, set, nodesel) + ccall((:SCIPtreeCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_TREE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), tree, blkmem, set, nodesel) end -function SCIPdecompGetVarsLabels(decomp, vars, labels, nvars) - ccall( - (:SCIPdecompGetVarsLabels, libscip), - Cvoid, - (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), - decomp, - vars, - labels, - nvars, - ) +function SCIPtreeFree(tree, blkmem, set, stat, eventqueue, eventfilter, lp) + ccall((:SCIPtreeFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_TREE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}), tree, blkmem, set, stat, eventqueue, eventfilter, lp) end -function SCIPdecompSetConsLabels(decomp, conss, labels, nconss) - ccall( - (:SCIPdecompSetConsLabels, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), - decomp, - conss, - labels, - nconss, - ) +function SCIPtreeClear(tree, blkmem, set, stat, eventqueue, eventfilter, lp) + ccall((:SCIPtreeClear, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}), tree, blkmem, set, stat, eventqueue, eventfilter, lp) end -function SCIPdecompGetConsLabels(decomp, conss, labels, nconss) - ccall( - (:SCIPdecompGetConsLabels, libscip), - Cvoid, - (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), - decomp, - conss, - labels, - nconss, - ) +function SCIPtreeCreateRoot(tree, reopt, blkmem, set, stat, eventqueue, eventfilter, lp) + ccall((:SCIPtreeCreateRoot, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}), tree, reopt, blkmem, set, stat, eventqueue, eventfilter, lp) end -function SCIPdecompClear(decomp, clearvarlabels, clearconslabels) - ccall( - (:SCIPdecompClear, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DECOMP}, Cuint, Cuint), - decomp, - clearvarlabels, - clearconslabels, - ) +function SCIPtreeCreatePresolvingRoot(tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, primal, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable) + ccall((:SCIPtreeCreatePresolvingRoot, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_CONFLICT}, Ptr{SCIP_CONFLICTSTORE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}), tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, primal, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable) end -function SCIPdecompPrintStats(decomp, strbuf) - ccall( - (:SCIPdecompPrintStats, libscip), - Ptr{Cchar}, - (Ptr{SCIP_DECOMP}, Ptr{Cchar}), - decomp, - strbuf, - ) +function SCIPtreeFreePresolvingRoot(tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, primal, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable) + ccall((:SCIPtreeFreePresolvingRoot, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_CONFLICT}, Ptr{SCIP_CONFLICTSTORE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}), tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, primal, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable) end -function SCIPdialoghdlrGetRoot(dialoghdlr) - ccall( - (:SCIPdialoghdlrGetRoot, libscip), - Ptr{SCIP_DIALOG}, - (Ptr{SCIP_DIALOGHDLR},), - dialoghdlr, - ) +function SCIPtreeGetNodesel(tree) + ccall((:SCIPtreeGetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_TREE},), tree) end -function SCIPdialoghdlrClearBuffer(dialoghdlr) - ccall( - (:SCIPdialoghdlrClearBuffer, libscip), - Cvoid, - (Ptr{SCIP_DIALOGHDLR},), - dialoghdlr, - ) +function SCIPtreeSetNodesel(tree, set, messagehdlr, stat, nodesel) + ccall((:SCIPtreeSetNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_NODESEL}), tree, set, messagehdlr, stat, nodesel) end -function SCIPdialoghdlrIsBufferEmpty(dialoghdlr) - ccall( - (:SCIPdialoghdlrIsBufferEmpty, libscip), - Cuint, - (Ptr{SCIP_DIALOGHDLR},), - dialoghdlr, - ) +function SCIPtreeCutoff(tree, reopt, blkmem, set, stat, eventqueue, eventfilter, lp, cutoffbound) + ccall((:SCIPtreeCutoff, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}, Cdouble), tree, reopt, blkmem, set, stat, eventqueue, eventfilter, lp, cutoffbound) end -function SCIPdialoghdlrGetLine(dialoghdlr, dialog, prompt, inputline, endoffile) - ccall( - (:SCIPdialoghdlrGetLine, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_DIALOGHDLR}, - Ptr{SCIP_DIALOG}, - Ptr{Cchar}, - Ptr{Ptr{Cchar}}, - Ptr{Cuint}, - ), - dialoghdlr, - dialog, - prompt, - inputline, - endoffile, - ) +function SCIPtreeLoadLP(tree, blkmem, set, eventqueue, eventfilter, lp, initroot) + ccall((:SCIPtreeLoadLP, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}, Ptr{Cuint}), tree, blkmem, set, eventqueue, eventfilter, lp, initroot) end -function SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, inputword, endoffile) - ccall( - (:SCIPdialoghdlrGetWord, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_DIALOGHDLR}, - Ptr{SCIP_DIALOG}, - Ptr{Cchar}, - Ptr{Ptr{Cchar}}, - Ptr{Cuint}, - ), - dialoghdlr, - dialog, - prompt, - inputword, - endoffile, - ) +function SCIPtreeLoadLPState(tree, blkmem, set, prob, stat, eventqueue, lp) + ccall((:SCIPtreeLoadLPState, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), tree, blkmem, set, prob, stat, eventqueue, lp) end -function SCIPdialoghdlrAddInputLine(dialoghdlr, inputline) - ccall( - (:SCIPdialoghdlrAddInputLine, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIALOGHDLR}, Ptr{Cchar}), - dialoghdlr, - inputline, - ) +function SCIPtreeCalcNodeselPriority(tree, set, stat, var, branchdir, targetvalue) + ccall((:SCIPtreeCalcNodeselPriority, libscip), Cdouble, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), tree, set, stat, var, branchdir, targetvalue) end -function SCIPdialoghdlrAddHistory(dialoghdlr, dialog, command, escapecommand) - ccall( - (:SCIPdialoghdlrAddHistory, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Ptr{Cchar}, Cuint), - dialoghdlr, - dialog, - command, - escapecommand, - ) +function SCIPtreeCalcChildEstimate(tree, set, stat, var, targetvalue) + ccall((:SCIPtreeCalcChildEstimate, libscip), Cdouble, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, Cdouble), tree, set, stat, var, targetvalue) end -function SCIPdialogHasEntry(dialog, entryname) - ccall( - (:SCIPdialogHasEntry, libscip), - Cuint, - (Ptr{SCIP_DIALOG}, Ptr{Cchar}), - dialog, - entryname, - ) +function SCIPtreeBranchVar(tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, val, downchild, eqchild, upchild) + ccall((:SCIPtreeBranchVar, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_VAR}, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, val, downchild, eqchild, upchild) end -function SCIPdialogFindEntry(dialog, entryname, subdialog) - ccall( - (:SCIPdialogFindEntry, libscip), - Cint, - (Ptr{SCIP_DIALOG}, Ptr{Cchar}, Ptr{Ptr{SCIP_DIALOG}}), - dialog, - entryname, - subdialog, - ) +function SCIPtreeBranchVarExact(tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, downchild, upchild) + ccall((:SCIPtreeBranchVarExact, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, downchild, upchild) end -function SCIPdialogDisplayMenu(dialog, scip) - ccall( - (:SCIPdialogDisplayMenu, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIALOG}, Ptr{SCIP}), - dialog, - scip, - ) +function SCIPtreeBranchVarHole(tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, left, right, downchild, upchild) + ccall((:SCIPtreeBranchVarHole, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, left, right, downchild, upchild) end -function SCIPdialogDisplayMenuEntry(dialog, scip) - ccall( - (:SCIPdialogDisplayMenuEntry, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIALOG}, Ptr{SCIP}), - dialog, - scip, - ) +function SCIPtreeBranchVarNary(tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, val, n, minwidth, widthfactor, nchildren) + ccall((:SCIPtreeBranchVarNary, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_VAR}, Cdouble, Cint, Cdouble, Cdouble, Ptr{Cint}), tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, val, n, minwidth, widthfactor, nchildren) end -function SCIPdialogDisplayCompletions(dialog, scip, entryname) - ccall( - (:SCIPdialogDisplayCompletions, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIALOG}, Ptr{SCIP}, Ptr{Cchar}), - dialog, - scip, - entryname, - ) +function SCIPtreeAddDiveBoundChange(tree, blkmem, var, dir, value, preferred) + ccall((:SCIPtreeAddDiveBoundChange, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble, Cuint), tree, blkmem, var, dir, value, preferred) end -function SCIPdialogGetPath(dialog, sepchar, path) - ccall( - (:SCIPdialogGetPath, libscip), - Cvoid, - (Ptr{SCIP_DIALOG}, Cchar, Ptr{Cchar}), - dialog, - sepchar, - path, - ) +function SCIPtreeGetDiveBoundChangeData(tree, variables, directions, values, ndivebdchgs, preferred) + ccall((:SCIPtreeGetDiveBoundChangeData, libscip), Cvoid, (Ptr{SCIP_TREE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{SCIP_BRANCHDIR}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Cuint), tree, variables, directions, values, ndivebdchgs, preferred) end -function SCIPdialogGetName(dialog) - ccall( - (:SCIPdialogGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_DIALOG},), - dialog, - ) +function SCIPtreeClearDiveBoundChanges(tree) + ccall((:SCIPtreeClearDiveBoundChanges, libscip), Cvoid, (Ptr{SCIP_TREE},), tree) end -function SCIPdialogGetDesc(dialog) - ccall( - (:SCIPdialogGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_DIALOG},), - dialog, - ) +function SCIPtreeStartProbing(tree, blkmem, set, lp, relaxation, transprob, strongbranching) + ccall((:SCIPtreeStartProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PROB}, Cuint), tree, blkmem, set, lp, relaxation, transprob, strongbranching) end -function SCIPdialogIsSubmenu(dialog) - ccall((:SCIPdialogIsSubmenu, libscip), Cuint, (Ptr{SCIP_DIALOG},), dialog) +function SCIPtreeCreateProbingNode(tree, blkmem, set, lp) + ccall((:SCIPtreeCreateProbingNode, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), tree, blkmem, set, lp) end -function SCIPdialogGetParent(dialog) - ccall( - (:SCIPdialogGetParent, libscip), - Ptr{SCIP_DIALOG}, - (Ptr{SCIP_DIALOG},), - dialog, - ) +function SCIPtreeSetProbingLPState(tree, blkmem, lp, lpistate, lpinorms, primalfeas, dualfeas) + ccall((:SCIPtreeSetProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}, Ptr{Ptr{SCIP_LPISTATE}}, Ptr{Ptr{SCIP_LPINORMS}}, Cuint, Cuint), tree, blkmem, lp, lpistate, lpinorms, primalfeas, dualfeas) end -function SCIPdialogGetSubdialogs(dialog) - ccall( - (:SCIPdialogGetSubdialogs, libscip), - Ptr{Ptr{SCIP_DIALOG}}, - (Ptr{SCIP_DIALOG},), - dialog, - ) +function SCIPtreeLoadProbingLPState(tree, blkmem, set, prob, eventqueue, lp) + ccall((:SCIPtreeLoadProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), tree, blkmem, set, prob, eventqueue, lp) end -function SCIPdialogGetNSubdialogs(dialog) - ccall( - (:SCIPdialogGetNSubdialogs, libscip), - Cint, - (Ptr{SCIP_DIALOG},), - dialog, - ) +function SCIPtreeMarkProbingNodeHasLP(tree, blkmem, lp) + ccall((:SCIPtreeMarkProbingNodeHasLP, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}), tree, blkmem, lp) end -function SCIPdialogGetData(dialog) - ccall( - (:SCIPdialogGetData, libscip), - Ptr{SCIP_DIALOGDATA}, - (Ptr{SCIP_DIALOG},), - dialog, - ) +function SCIPtreeBacktrackProbing(tree, reopt, blkmem, set, stat, transprob, origprob, lp, primal, branchcand, eventqueue, eventfilter, cliquetable, probingdepth) + ccall((:SCIPtreeBacktrackProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Cint), tree, reopt, blkmem, set, stat, transprob, origprob, lp, primal, branchcand, eventqueue, eventfilter, cliquetable, probingdepth) end -function SCIPdialogSetData(dialog, dialogdata) - ccall( - (:SCIPdialogSetData, libscip), - Cvoid, - (Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGDATA}), - dialog, - dialogdata, - ) +function SCIPtreeEndProbing(tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, lp, relaxation, primal, branchcand, eventqueue, eventfilter, cliquetable) + ccall((:SCIPtreeEndProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}), tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, lp, relaxation, primal, branchcand, eventqueue, eventfilter, cliquetable) end -function SCIPdialogWriteHistory(filename) - ccall( - (:SCIPdialogWriteHistory, libscip), - SCIP_RETCODE, - (Ptr{Cchar},), - filename, - ) +function SCIPtreeStoreRelaxSol(tree, set, relaxation, transprob) + ccall((:SCIPtreeStoreRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PROB}), tree, set, relaxation, transprob) end -function SCIPdispGetData(disp) - ccall( - (:SCIPdispGetData, libscip), - Ptr{SCIP_DISPDATA}, - (Ptr{SCIP_DISP},), - disp, - ) +function SCIPtreeRestoreRelaxSol(tree, set, relaxation, transprob) + ccall((:SCIPtreeRestoreRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PROB}), tree, set, relaxation, transprob) end -function SCIPdispSetData(disp, dispdata) - ccall( - (:SCIPdispSetData, libscip), - Cvoid, - (Ptr{SCIP_DISP}, Ptr{SCIP_DISPDATA}), - disp, - dispdata, - ) +function SCIPtreeGetNChildren(tree) + ccall((:SCIPtreeGetNChildren, libscip), Cint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispGetName(disp) - ccall((:SCIPdispGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_DISP},), disp) +function SCIPtreeGetNSiblings(tree) + ccall((:SCIPtreeGetNSiblings, libscip), Cint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispGetDesc(disp) - ccall((:SCIPdispGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_DISP},), disp) +function SCIPtreeGetNLeaves(tree) + ccall((:SCIPtreeGetNLeaves, libscip), Cint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispGetHeader(disp) - ccall((:SCIPdispGetHeader, libscip), Ptr{Cchar}, (Ptr{SCIP_DISP},), disp) +function SCIPtreeGetNNodes(tree) + ccall((:SCIPtreeGetNNodes, libscip), Cint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispGetWidth(disp) - ccall((:SCIPdispGetWidth, libscip), Cint, (Ptr{SCIP_DISP},), disp) +function SCIPtreeIsPathComplete(tree) + ccall((:SCIPtreeIsPathComplete, libscip), Cuint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispGetPriority(disp) - ccall((:SCIPdispGetPriority, libscip), Cint, (Ptr{SCIP_DISP},), disp) +function SCIPtreeProbing(tree) + ccall((:SCIPtreeProbing, libscip), Cuint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispGetPosition(disp) - ccall((:SCIPdispGetPosition, libscip), Cint, (Ptr{SCIP_DISP},), disp) +function SCIPtreeGetProbingRoot(tree) + ccall((:SCIPtreeGetProbingRoot, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) end -function SCIPdispGetStatus(disp) - ccall( - (:SCIPdispGetStatus, libscip), - SCIP_DISPSTATUS, - (Ptr{SCIP_DISP},), - disp, - ) +function SCIPtreeGetProbingDepth(tree) + ccall((:SCIPtreeGetProbingDepth, libscip), Cint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispIsInitialized(disp) - ccall((:SCIPdispIsInitialized, libscip), Cuint, (Ptr{SCIP_DISP},), disp) +function SCIPtreeGetFocusNode(tree) + ccall((:SCIPtreeGetFocusNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) end -function SCIPdispLongint(messagehdlr, file, val, width) - ccall( - (:SCIPdispLongint, libscip), - Cvoid, - (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Clonglong, Cint), - messagehdlr, - file, - val, - width, - ) +function SCIPtreeGetFocusDepth(tree) + ccall((:SCIPtreeGetFocusDepth, libscip), Cint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispInt(messagehdlr, file, val, width) - ccall( - (:SCIPdispInt, libscip), - Cvoid, - (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Cint, Cint), - messagehdlr, - file, - val, - width, - ) +function SCIPtreeHasFocusNodeLP(tree) + ccall((:SCIPtreeHasFocusNodeLP, libscip), Cuint, (Ptr{SCIP_TREE},), tree) end -function SCIPdispTime(messagehdlr, file, val, width) - ccall( - (:SCIPdispTime, libscip), - Cvoid, - (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Cdouble, Cint), - messagehdlr, - file, - val, - width, - ) +function SCIPtreeSetFocusNodeLP(tree, solvelp) + ccall((:SCIPtreeSetFocusNodeLP, libscip), Cvoid, (Ptr{SCIP_TREE}, Cuint), tree, solvelp) end -function SCIPeventhdlrGetName(eventhdlr) - ccall( - (:SCIPeventhdlrGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_EVENTHDLR},), - eventhdlr, - ) +function SCIPtreeIsFocusNodeLPConstructed(tree) + ccall((:SCIPtreeIsFocusNodeLPConstructed, libscip), Cuint, (Ptr{SCIP_TREE},), tree) end -function SCIPeventhdlrGetData(eventhdlr) - ccall( - (:SCIPeventhdlrGetData, libscip), - Ptr{SCIP_EVENTHDLRDATA}, - (Ptr{SCIP_EVENTHDLR},), - eventhdlr, - ) +function SCIPtreeInRepropagation(tree) + ccall((:SCIPtreeInRepropagation, libscip), Cuint, (Ptr{SCIP_TREE},), tree) end -function SCIPeventhdlrSetData(eventhdlr, eventhdlrdata) - ccall( - (:SCIPeventhdlrSetData, libscip), - Cvoid, - (Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTHDLRDATA}), - eventhdlr, - eventhdlrdata, - ) +function SCIPtreeGetCurrentNode(tree) + ccall((:SCIPtreeGetCurrentNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) end -function SCIPeventhdlrIsInitialized(eventhdlr) - ccall( - (:SCIPeventhdlrIsInitialized, libscip), - Cuint, - (Ptr{SCIP_EVENTHDLR},), - eventhdlr, - ) +function SCIPtreeGetCurrentDepth(tree) + ccall((:SCIPtreeGetCurrentDepth, libscip), Cint, (Ptr{SCIP_TREE},), tree) end -function SCIPeventhdlrGetSetupTime(eventhdlr) - ccall( - (:SCIPeventhdlrGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_EVENTHDLR},), - eventhdlr, - ) +function SCIPtreeHasCurrentNodeLP(tree) + ccall((:SCIPtreeHasCurrentNodeLP, libscip), Cuint, (Ptr{SCIP_TREE},), tree) end -function SCIPeventhdlrGetTime(eventhdlr) - ccall( - (:SCIPeventhdlrGetTime, libscip), - Cdouble, - (Ptr{SCIP_EVENTHDLR},), - eventhdlr, - ) +function SCIPtreeGetEffectiveRootDepth(tree) + ccall((:SCIPtreeGetEffectiveRootDepth, libscip), Cint, (Ptr{SCIP_TREE},), tree) end -function SCIPeventGetType(event) - ccall( - (:SCIPeventGetType, libscip), - SCIP_EVENTTYPE, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPtreeGetRootNode(tree) + ccall((:SCIPtreeGetRootNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) end -function SCIPeventGetVar(event) - ccall((:SCIPeventGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_EVENT},), event) +function SCIPtreeProbingObjChanged(tree) + ccall((:SCIPtreeProbingObjChanged, libscip), Cuint, (Ptr{SCIP_TREE},), tree) end -function SCIPeventGetOldobj(event) - ccall((:SCIPeventGetOldobj, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +function SCIPtreeMarkProbingObjChanged(tree) + ccall((:SCIPtreeMarkProbingObjChanged, libscip), Cvoid, (Ptr{SCIP_TREE},), tree) end -function SCIPeventGetNewobj(event) - ccall((:SCIPeventGetNewobj, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +function SCIPtreeGetPrioChild(tree) + ccall((:SCIPtreeGetPrioChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) end -function SCIPeventGetOldbound(event) - ccall((:SCIPeventGetOldbound, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +function SCIPtreeGetPrioSibling(tree) + ccall((:SCIPtreeGetPrioSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) end -function SCIPeventGetNewbound(event) - ccall((:SCIPeventGetNewbound, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +function SCIPtreeGetBestChild(tree, set) + ccall((:SCIPtreeGetBestChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) end -function SCIPeventGetOldtype(event) - ccall( - (:SCIPeventGetOldtype, libscip), - SCIP_VARTYPE, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPtreeGetBestSibling(tree, set) + ccall((:SCIPtreeGetBestSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) end -function SCIPeventGetNewtype(event) - ccall( - (:SCIPeventGetNewtype, libscip), - SCIP_VARTYPE, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPtreeGetBestLeaf(tree) + ccall((:SCIPtreeGetBestLeaf, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) end -function SCIPeventGetNode(event) - ccall( - (:SCIPeventGetNode, libscip), - Ptr{SCIP_NODE}, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPtreeGetBestNode(tree, set) + ccall((:SCIPtreeGetBestNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) end -function SCIPeventGetSol(event) - ccall((:SCIPeventGetSol, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP_EVENT},), event) +function SCIPtreeGetLowerbound(tree, set) + ccall((:SCIPtreeGetLowerbound, libscip), Cdouble, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) end -function SCIPeventGetHoleLeft(event) - ccall((:SCIPeventGetHoleLeft, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +function SCIPtreeGetLowerboundExact(tree, set) + ccall((:SCIPtreeGetLowerboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) end -function SCIPeventGetHoleRight(event) - ccall((:SCIPeventGetHoleRight, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +function SCIPtreeGetLowerboundNode(tree, set) + ccall((:SCIPtreeGetLowerboundNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) end -function SCIPeventGetRow(event) - ccall((:SCIPeventGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_EVENT},), event) +function SCIPtreeGetAvgLowerbound(tree, cutoffbound) + ccall((:SCIPtreeGetAvgLowerbound, libscip), Cdouble, (Ptr{SCIP_TREE}, Cdouble), tree, cutoffbound) end -function SCIPeventGetRowCol(event) - ccall( - (:SCIPeventGetRowCol, libscip), - Ptr{SCIP_COL}, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPtreeWasNodeLastBranchParent(tree, node) + ccall((:SCIPtreeWasNodeLastBranchParent, libscip), Cuint, (Ptr{SCIP_TREE}, Ptr{SCIP_NODE}), tree, node) end -function SCIPeventGetRowOldCoefVal(event) - ccall( - (:SCIPeventGetRowOldCoefVal, libscip), - Cdouble, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPincludeConshdlrExactSol(scip) + ccall((:SCIPincludeConshdlrExactSol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPeventGetRowNewCoefVal(event) - ccall( - (:SCIPeventGetRowNewCoefVal, libscip), - Cdouble, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPincludeConshdlrLinking(scip) + ccall((:SCIPincludeConshdlrLinking, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPeventGetRowOldConstVal(event) - ccall( - (:SCIPeventGetRowOldConstVal, libscip), - Cdouble, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPcreateConsLinking(scip, cons, name, linkvar, binvars, vals, nbinvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsLinking, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, linkvar, binvars, vals, nbinvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) end -function SCIPeventGetRowNewConstVal(event) - ccall( - (:SCIPeventGetRowNewConstVal, libscip), - Cdouble, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPcreateConsBasicLinking(scip, cons, name, linkvar, binvars, vals, nbinvars) + ccall((:SCIPcreateConsBasicLinking, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), scip, cons, name, linkvar, binvars, vals, nbinvars) end -function SCIPeventGetRowSide(event) - ccall( - (:SCIPeventGetRowSide, libscip), - SCIP_SIDETYPE, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPexistsConsLinking(scip, linkvar) + ccall((:SCIPexistsConsLinking, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, linkvar) end -function SCIPeventGetRowOldSideVal(event) - ccall( - (:SCIPeventGetRowOldSideVal, libscip), - Cdouble, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPgetConsLinking(scip, linkvar) + ccall((:SCIPgetConsLinking, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, linkvar) end -function SCIPeventGetRowNewSideVal(event) - ccall( - (:SCIPeventGetRowNewSideVal, libscip), - Cdouble, - (Ptr{SCIP_EVENT},), - event, - ) +function SCIPgetLinkvarLinking(scip, cons) + ccall((:SCIPgetLinkvarLinking, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrSetCopyFreeHdlr(exprhdlr, copyhdlr, freehdlr) - ccall( - (:SCIPexprhdlrSetCopyFreeHdlr, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), - exprhdlr, - copyhdlr, - freehdlr, - ) +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 SCIPexprhdlrSetCopyFreeData(exprhdlr, copydata, freedata) - ccall( - (:SCIPexprhdlrSetCopyFreeData, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), - exprhdlr, - copydata, - freedata, - ) +function SCIPgetNBinvarsLinking(scip, cons) + ccall((:SCIPgetNBinvarsLinking, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrSetPrint(exprhdlr, print) - ccall( - (:SCIPexprhdlrSetPrint, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - print, - ) +function SCIPgetValsLinking(scip, cons) + ccall((:SCIPgetValsLinking, libscip), Ptr{Cdouble}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrSetParse(exprhdlr, parse) - ccall( - (:SCIPexprhdlrSetParse, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - parse, - ) +function SCIPgetBinvarsDataLinking(cons, binvars, vals, nbinvars) + ccall((:SCIPgetBinvarsDataLinking, libscip), SCIP_RETCODE, (Ptr{SCIP_CONS}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}), cons, binvars, vals, nbinvars) end -function SCIPexprhdlrSetCurvature(exprhdlr, curvature) - ccall( - (:SCIPexprhdlrSetCurvature, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - curvature, - ) +function SCIPincludeConshdlrLogicor(scip) + ccall((:SCIPincludeConshdlrLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPexprhdlrSetMonotonicity(exprhdlr, monotonicity) - ccall( - (:SCIPexprhdlrSetMonotonicity, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - monotonicity, - ) +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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) end -function SCIPexprhdlrSetIntegrality(exprhdlr, integrality) - ccall( - (:SCIPexprhdlrSetIntegrality, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - integrality, - ) +function SCIPcreateConsBasicLogicor(scip, cons, name, nvars, vars) + ccall((:SCIPcreateConsBasicLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, nvars, vars) end -function SCIPexprhdlrSetHash(exprhdlr, hash) - ccall( - (:SCIPexprhdlrSetHash, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - hash, - ) +function SCIPaddCoefLogicor(scip, cons, var) + ccall((:SCIPaddCoefLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, var) end -function SCIPexprhdlrSetCompare(exprhdlr, compare) - ccall( - (:SCIPexprhdlrSetCompare, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - compare, - ) +function SCIPgetNVarsLogicor(scip, cons) + ccall((:SCIPgetNVarsLogicor, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrSetDiff(exprhdlr, bwdiff, fwdiff, bwfwdiff) - ccall( - (:SCIPexprhdlrSetDiff, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), - exprhdlr, - bwdiff, - fwdiff, - bwfwdiff, - ) +function SCIPgetVarsLogicor(scip, cons) + ccall((:SCIPgetVarsLogicor, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrSetIntEval(exprhdlr, inteval) - ccall( - (:SCIPexprhdlrSetIntEval, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - inteval, - ) +function SCIPgetDualsolLogicor(scip, cons) + ccall((:SCIPgetDualsolLogicor, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrSetSimplify(exprhdlr, simplify) - ccall( - (:SCIPexprhdlrSetSimplify, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - simplify, - ) +function SCIPgetDualfarkasLogicor(scip, cons) + ccall((:SCIPgetDualfarkasLogicor, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrSetReverseProp(exprhdlr, reverseprop) - ccall( - (:SCIPexprhdlrSetReverseProp, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), - exprhdlr, - reverseprop, - ) +function SCIPgetRowLogicor(scip, cons) + ccall((:SCIPgetRowLogicor, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrSetEstimate(exprhdlr, initestimates, estimate) - ccall( - (:SCIPexprhdlrSetEstimate, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), - exprhdlr, - initestimates, - estimate, - ) +function SCIPcreateRowLogicor(scip, cons) + ccall((:SCIPcreateRowLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPexprhdlrGetName(exprhdlr) - ccall( - (:SCIPexprhdlrGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPcleanupConssLogicor(scip, onlychecked, naddconss, ndelconss, nchgcoefs) + ccall((:SCIPcleanupConssLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, onlychecked, naddconss, ndelconss, nchgcoefs) end -function SCIPexprhdlrGetDescription(exprhdlr) - ccall( - (:SCIPexprhdlrGetDescription, libscip), - Ptr{Cchar}, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +struct SCIP_ConsNonlinear_Auxexpr + coefs::NTuple{3, Cdouble} + cst::Cdouble + auxvar::Ptr{SCIP_VAR} + underestimate::Cuint + overestimate::Cuint end -function SCIPexprhdlrGetPrecedence(exprhdlr) - ccall( - (:SCIPexprhdlrGetPrecedence, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) -end +const SCIP_CONSNONLINEAR_AUXEXPR = SCIP_ConsNonlinear_Auxexpr -function SCIPexprhdlrGetData(exprhdlr) - ccall( - (:SCIPexprhdlrGetData, libscip), - Ptr{SCIP_EXPRHDLRDATA}, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +struct __JL_Ctag_88 + data::NTuple{8, UInt8} end -function SCIPexprhdlrHasPrint(exprhdlr) - ccall( - (:SCIPexprhdlrHasPrint, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function Base.getproperty(x::Ptr{__JL_Ctag_88}, f::Symbol) + f === :exprs && return Ptr{Ptr{Ptr{SCIP_CONSNONLINEAR_AUXEXPR}}}(x + 0) + f === :var && return Ptr{Ptr{SCIP_VAR}}(x + 0) + return getfield(x, f) end -function SCIPexprhdlrHasBwdiff(exprhdlr) - ccall( - (:SCIPexprhdlrHasBwdiff, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function Base.getproperty(x::__JL_Ctag_88, f::Symbol) + r = Ref{__JL_Ctag_88}(x) + ptr = Base.unsafe_convert(Ptr{__JL_Ctag_88}, r) + fptr = getproperty(ptr, f) + GC.@preserve r unsafe_load(fptr) end -function SCIPexprhdlrHasFwdiff(exprhdlr) - ccall( - (:SCIPexprhdlrHasFwdiff, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function Base.setproperty!(x::Ptr{__JL_Ctag_88}, f::Symbol, v) + unsafe_store!(getproperty(x, f), v) end -function SCIPexprhdlrHasIntEval(exprhdlr) - ccall( - (:SCIPexprhdlrHasIntEval, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function Base.propertynames(x::__JL_Ctag_88, private::Bool = false) + (:exprs, :var, if private + fieldnames(typeof(x)) + else + () + end...) end -function SCIPexprhdlrHasEstimate(exprhdlr) - ccall( - (:SCIPexprhdlrHasEstimate, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +struct SCIP_ConsNonlinear_BilinTerm + data::NTuple{48, UInt8} end -function SCIPexprhdlrHasInitEstimates(exprhdlr) - ccall( - (:SCIPexprhdlrHasInitEstimates, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function Base.getproperty(x::Ptr{SCIP_ConsNonlinear_BilinTerm}, f::Symbol) + f === :x && return Ptr{Ptr{SCIP_VAR}}(x + 0) + f === :y && return Ptr{Ptr{SCIP_VAR}}(x + 8) + f === :aux && return Ptr{__JL_Ctag_88}(x + 16) + f === :nauxexprs && return Ptr{Cint}(x + 24) + f === :auxexprssize && return Ptr{Cint}(x + 28) + f === :nlockspos && return Ptr{Cint}(x + 32) + f === :nlocksneg && return Ptr{Cint}(x + 36) + f === :existing && return Ptr{Cuint}(x + 40) + return getfield(x, f) end -function SCIPexprhdlrHasSimplify(exprhdlr) - ccall( - (:SCIPexprhdlrHasSimplify, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function Base.getproperty(x::SCIP_ConsNonlinear_BilinTerm, f::Symbol) + r = Ref{SCIP_ConsNonlinear_BilinTerm}(x) + ptr = Base.unsafe_convert(Ptr{SCIP_ConsNonlinear_BilinTerm}, r) + fptr = getproperty(ptr, f) + GC.@preserve r unsafe_load(fptr) end -function SCIPexprhdlrHasCurvature(exprhdlr) - ccall( - (:SCIPexprhdlrHasCurvature, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function Base.setproperty!(x::Ptr{SCIP_ConsNonlinear_BilinTerm}, f::Symbol, v) + unsafe_store!(getproperty(x, f), v) end -function SCIPexprhdlrHasMonotonicity(exprhdlr) - ccall( - (:SCIPexprhdlrHasMonotonicity, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function Base.propertynames(x::SCIP_ConsNonlinear_BilinTerm, private::Bool = false) + (:x, :y, :aux, :nauxexprs, :auxexprssize, :nlockspos, :nlocksneg, :existing, if private + fieldnames(typeof(x)) + else + () + end...) end -function SCIPexprhdlrHasReverseProp(exprhdlr) - ccall( - (:SCIPexprhdlrHasReverseProp, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) -end +const SCIP_CONSNONLINEAR_BILINTERM = SCIP_ConsNonlinear_BilinTerm + +function SCIPincludeConshdlrNonlinear(scip) + ccall((:SCIPincludeConshdlrNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeConsUpgradeNonlinear(scip, nlconsupgd, priority, active, conshdlrname) + ccall((:SCIPincludeConsUpgradeNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}, Cint, Cuint, Ptr{Cchar}), scip, nlconsupgd, priority, active, conshdlrname) +end + +function SCIPcreateConsNonlinear(scip, cons, name, expr, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) + ccall((:SCIPcreateConsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_EXPR}, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, expr, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) +end + +function SCIPcreateConsBasicNonlinear(scip, cons, name, expr, lhs, rhs) + ccall((:SCIPcreateConsBasicNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_EXPR}, Cdouble, Cdouble), scip, cons, name, expr, lhs, rhs) +end + +function SCIPcreateConsQuadraticNonlinear(scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) + ccall((:SCIPcreateConsQuadraticNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) +end + +function SCIPcreateConsBasicQuadraticNonlinear(scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs) + ccall((:SCIPcreateConsBasicQuadraticNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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 SCIPcreateConsBasicSOCNonlinear(scip, cons, name, nvars, vars, coefs, offsets, constant, rhsvar, rhscoeff, rhsoffset) + ccall((:SCIPcreateConsBasicSOCNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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 SCIPcreateConsBasicSignpowerNonlinear(scip, cons, name, x, z, exponent, xoffset, zcoef, lhs, rhs) + ccall((:SCIPcreateConsBasicSignpowerNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, cons, name, x, z, exponent, xoffset, zcoef, lhs, rhs) +end + +function SCIPgetCurBoundsTagNonlinear(conshdlr) + ccall((:SCIPgetCurBoundsTagNonlinear, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPgetLastBoundRelaxTagNonlinear(conshdlr) + ccall((:SCIPgetLastBoundRelaxTagNonlinear, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPincrementCurBoundsTagNonlinear(conshdlr, boundrelax) + ccall((:SCIPincrementCurBoundsTagNonlinear, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Cuint), conshdlr, boundrelax) +end + +function SCIPgetVarExprHashmapNonlinear(conshdlr) + ccall((:SCIPgetVarExprHashmapNonlinear, libscip), Ptr{SCIP_HASHMAP}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPprocessRowprepNonlinear(scip, nlhdlr, cons, expr, rowprep, overestimate, auxvar, auxvalue, allowweakcuts, branchscoresuccess, inenforcement, sol, result) + ccall((:SCIPprocessRowprepNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLHDLR}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}, Ptr{SCIP_ROWPREP}, Cuint, Ptr{SCIP_VAR}, Cdouble, Cuint, Cuint, Cuint, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, nlhdlr, cons, expr, rowprep, overestimate, auxvar, auxvalue, allowweakcuts, branchscoresuccess, inenforcement, sol, result) +end + +function SCIPassumeConvexNonlinear(conshdlr) + ccall((:SCIPassumeConvexNonlinear, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPcollectBilinTermsNonlinear(scip, conshdlr, conss, nconss) + ccall((:SCIPcollectBilinTermsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Ptr{SCIP_CONS}}, Cint), scip, conshdlr, conss, nconss) +end + +function SCIPgetNBilinTermsNonlinear(conshdlr) + ccall((:SCIPgetNBilinTermsNonlinear, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPgetBilinTermsNonlinear(conshdlr) + ccall((:SCIPgetBilinTermsNonlinear, libscip), Ptr{SCIP_CONSNONLINEAR_BILINTERM}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPgetBilinTermIdxNonlinear(conshdlr, x, y) + ccall((:SCIPgetBilinTermIdxNonlinear, libscip), Cint, (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), conshdlr, x, y) +end + +function SCIPgetBilinTermNonlinear(conshdlr, x, y) + ccall((:SCIPgetBilinTermNonlinear, libscip), Ptr{SCIP_CONSNONLINEAR_BILINTERM}, (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), conshdlr, x, y) +end + +function SCIPevalBilinAuxExprNonlinear(scip, x, y, auxexpr, sol) + ccall((:SCIPevalBilinAuxExprNonlinear, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Ptr{SCIP_CONSNONLINEAR_AUXEXPR}, Ptr{SCIP_SOL}), scip, x, y, auxexpr, sol) +end + +function SCIPinsertBilinearTermExistingNonlinear(scip, conshdlr, x, y, auxvar, nlockspos, nlocksneg) + ccall((:SCIPinsertBilinearTermExistingNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cint, Cint), scip, conshdlr, x, y, auxvar, nlockspos, nlocksneg) +end + +function SCIPinsertBilinearTermImplicitNonlinear(scip, conshdlr, x, y, auxvar, coefx, coefy, coefaux, cst, overestimate) + ccall((:SCIPinsertBilinearTermImplicitNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cuint), scip, conshdlr, x, y, auxvar, coefx, coefy, coefaux, cst, overestimate) +end + +function SCIPcomputeFacetVertexPolyhedralNonlinear(scip, conshdlr, overestimate, _function, fundata, xstar, box, nallvars, targetvalue, success, facetcoefs, facetconstant) + ccall((:SCIPcomputeFacetVertexPolyhedralNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cdouble}, Ptr{Cdouble}, Cint, Cdouble, Ptr{Cuint}, Ptr{Cdouble}, Ptr{Cdouble}), scip, conshdlr, overestimate, _function, fundata, xstar, box, nallvars, targetvalue, success, facetcoefs, facetconstant) +end + +function SCIPgetExprNonlinear(cons) + ccall((:SCIPgetExprNonlinear, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_CONS},), cons) +end + +function SCIPgetLhsNonlinear(cons) + ccall((:SCIPgetLhsNonlinear, libscip), Cdouble, (Ptr{SCIP_CONS},), cons) +end + +function SCIPgetRhsNonlinear(cons) + ccall((:SCIPgetRhsNonlinear, libscip), Cdouble, (Ptr{SCIP_CONS},), cons) +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 SCIPgetCurvatureNonlinear(cons) + ccall((:SCIPgetCurvatureNonlinear, libscip), SCIP_EXPRCURV, (Ptr{SCIP_CONS},), cons) +end + +function SCIPcheckQuadraticNonlinear(scip, cons, isquadratic) + ccall((:SCIPcheckQuadraticNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, isquadratic) +end + +function SCIPchgLhsNonlinear(scip, cons, lhs) + ccall((:SCIPchgLhsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, lhs) +end + +function SCIPchgRhsNonlinear(scip, cons, rhs) + ccall((:SCIPchgRhsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, rhs) +end + +function SCIPchgExprNonlinear(scip, cons, expr) + ccall((:SCIPchgExprNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}), scip, cons, expr) +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 SCIPaddExprNonlinear(scip, cons, expr, coef) + ccall((:SCIPaddExprNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}, Cdouble), scip, cons, expr, coef) +end + +function SCIPgetAbsViolationNonlinear(scip, cons, sol, viol) + ccall((:SCIPgetAbsViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, viol) +end + +function SCIPgetRelViolationNonlinear(scip, cons, sol, viol) + ccall((:SCIPgetRelViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, viol) +end + +function SCIPgetLinvarMayDecreaseNonlinear(scip, cons, var, coef) + ccall((:SCIPgetLinvarMayDecreaseNonlinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, var, coef) +end + +function SCIPgetLinvarMayIncreaseNonlinear(scip, cons, var, coef) + ccall((:SCIPgetLinvarMayIncreaseNonlinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, var, coef) +end + +function SCIPgetExprNLocksPosNonlinear(expr) + ccall((:SCIPgetExprNLocksPosNonlinear, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetExprNLocksNegNonlinear(expr) + ccall((:SCIPgetExprNLocksNegNonlinear, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetExprAuxVarNonlinear(expr) + ccall((:SCIPgetExprAuxVarNonlinear, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetExprNEnfosNonlinear(expr) + ccall((:SCIPgetExprNEnfosNonlinear, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetExprEnfoDataNonlinear(expr, idx, nlhdlr, nlhdlrexprdata, nlhdlrparticipation, sepabelowusesactivity, sepaaboveusesactivity, auxvalue) + ccall((:SCIPgetExprEnfoDataNonlinear, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint, Ptr{Ptr{SCIP_NLHDLR}}, Ptr{Ptr{SCIP_NLHDLREXPRDATA}}, Ptr{SCIP_NLHDLR_METHOD}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cdouble}), expr, idx, nlhdlr, nlhdlrexprdata, nlhdlrparticipation, sepabelowusesactivity, sepaaboveusesactivity, auxvalue) +end + +function SCIPsetExprEnfoAuxValueNonlinear(expr, idx, auxvalue) + ccall((:SCIPsetExprEnfoAuxValueNonlinear, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint, Cdouble), expr, idx, auxvalue) +end + +function SCIPgetExprNPropUsesActivityNonlinear(expr) + ccall((:SCIPgetExprNPropUsesActivityNonlinear, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetExprNSepaUsesActivityNonlinear(expr) + ccall((:SCIPgetExprNSepaUsesActivityNonlinear, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetExprNAuxvarUsesNonlinear(expr) + ccall((:SCIPgetExprNAuxvarUsesNonlinear, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPregisterExprUsageNonlinear(scip, expr, useauxvar, useactivityforprop, useactivityforsepabelow, useactivityforsepaabove) + ccall((:SCIPregisterExprUsageNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cuint, Cuint, Cuint, Cuint), scip, expr, useauxvar, useactivityforprop, useactivityforsepabelow, useactivityforsepaabove) +end + +function SCIPgetExprActivityNonlinear(scip, cons, sol, activity) + ccall((:SCIPgetExprActivityNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, activity) +end + +function SCIPgetExprAbsOrigViolationNonlinear(scip, expr, sol, soltag, viol, violunder, violover) + ccall((:SCIPgetExprAbsOrigViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}), scip, expr, sol, soltag, viol, violunder, violover) +end + +function SCIPgetExprAbsAuxViolationNonlinear(scip, expr, auxvalue, sol, viol, violunder, violover) + ccall((:SCIPgetExprAbsAuxViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cdouble, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}), scip, expr, auxvalue, sol, viol, violunder, violover) +end + +function SCIPgetExprRelAuxViolationNonlinear(scip, expr, auxvalue, sol, viol, violunder, violover) + ccall((:SCIPgetExprRelAuxViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cdouble, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}), scip, expr, auxvalue, sol, viol, violunder, violover) +end + +function SCIPgetExprBoundsNonlinear(scip, expr) + ccall((:SCIPgetExprBoundsNonlinear, libscip), SCIP_INTERVAL, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPtightenExprIntervalNonlinear(scip, expr, newbounds, cutoff, ntightenings) + ccall((:SCIPtightenExprIntervalNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_INTERVAL, Ptr{Cuint}, Ptr{Cint}), scip, expr, newbounds, cutoff, ntightenings) +end + +function SCIPmarkExprPropagateNonlinear(scip, expr) + ccall((:SCIPmarkExprPropagateNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPaddExprViolScoreNonlinear(scip, expr, violscore) + ccall((:SCIPaddExprViolScoreNonlinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cdouble), scip, expr, violscore) +end + +function SCIPaddExprsViolScoreNonlinear(scip, exprs, nexprs, violscore, sol, success) + ccall((:SCIPaddExprsViolScoreNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Cdouble, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, exprs, nexprs, violscore, sol, success) +end + +function SCIPgetExprViolScoreNonlinear(expr) + ccall((:SCIPgetExprViolScoreNonlinear, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetExprPartialDiffNonlinear(scip, expr, var) + ccall((:SCIPgetExprPartialDiffNonlinear, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_VAR}), scip, expr, var) +end + +function SCIPgetExprPartialDiffGradientDirNonlinear(scip, expr, var) + ccall((:SCIPgetExprPartialDiffGradientDirNonlinear, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_VAR}), scip, expr, var) +end + +function SCIPevalExprQuadraticAuxNonlinear(scip, expr, sol) + ccall((:SCIPevalExprQuadraticAuxNonlinear, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}), scip, expr, sol) +end + +function SCIPincludeNlhdlrNonlinear(scip, nlhdlr, name, desc, detectpriority, enfopriority, detect, evalaux, nlhdlrdata) + ccall((:SCIPincludeNlhdlrNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLHDLR}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NLHDLRDATA}), scip, nlhdlr, name, desc, detectpriority, enfopriority, detect, evalaux, nlhdlrdata) +end + +function SCIPgetNNlhdlrsNonlinear(conshdlr) + ccall((:SCIPgetNNlhdlrsNonlinear, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPgetNlhdlrsNonlinear(conshdlr) + ccall((:SCIPgetNlhdlrsNonlinear, libscip), Ptr{Ptr{SCIP_NLHDLR}}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPfindNlhdlrNonlinear(conshdlr, name) + ccall((:SCIPfindNlhdlrNonlinear, libscip), Ptr{SCIP_NLHDLR}, (Ptr{SCIP_CONSHDLR}, Ptr{Cchar}), conshdlr, name) +end + +function SCIPgetNlhdlrExprDataNonlinear(nlhdlr, expr) + ccall((:SCIPgetNlhdlrExprDataNonlinear, libscip), Ptr{SCIP_NLHDLREXPRDATA}, (Ptr{SCIP_NLHDLR}, Ptr{SCIP_EXPR}), nlhdlr, expr) +end + +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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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 + +function SCIPincludeConshdlrOrbisack(scip) + ccall((:SCIPincludeConshdlrOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +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, Cuint, Ptr{Cuint}), scip, sol, vars1, vars2, nrows, printreason, feasible) +end + +function SCIPcreateConsOrbisack(scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicOrbisack(scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, ismodelcons) + ccall((:SCIPcreateConsBasicOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cuint, Cuint), scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, ismodelcons) +end + +const SYM_SPEC = UInt32 + +@enum SYM_Symtype::UInt32 begin + SYM_SYMTYPE_PERM = 0 + SYM_SYMTYPE_SIGNPERM = 1 +end + +const SYM_SYMTYPE = SYM_Symtype + +@enum SYM_Nodetype::UInt32 begin + SYM_NODETYPE_OPERATOR = 0 + SYM_NODETYPE_VAL = 1 + SYM_NODETYPE_CONS = 2 + SYM_NODETYPE_VAR = 3 +end + +const SYM_NODETYPE = SYM_Nodetype + +@enum SYM_Consoptype::UInt32 begin + SYM_CONSOPTYPE_UNKNOWN = 0 + SYM_CONSOPTYPE_BDDISJ = 1 + SYM_CONSOPTYPE_EQ = 2 + SYM_CONSOPTYPE_SOS2_TUPLE = 3 + SYM_CONSOPTYPE_SUM = 4 + SYM_CONSOPTYPE_SLACK = 5 + SYM_CONSOPTYPE_COEF = 6 + SYM_CONSOPTYPE_SQDIFF = 7 + SYM_CONSOPTYPE_CARD_TUPLE = 8 + SYM_CONSOPTYPE_PB_AND = 9 + SYM_CONSOPTYPE_PB_LINEAR = 10 + SYM_CONSOPTYPE_PB_SOFT = 11 + SYM_CONSOPTYPE_PB_OBJ = 12 + SYM_CONSOPTYPE_AND = 13 + SYM_CONSOPTYPE_OR = 14 + SYM_CONSOPTYPE_XORINT = 15 + SYM_CONSOPTYPE_LAST = 16 +end + +const SYM_CONSOPTYPE = SYM_Consoptype + +const SYM_HANDLETYPE = UInt32 + +@enum SCIP_LeaderRule::UInt32 begin + SCIP_LEADERRULE_FIRSTINORBIT = 0 + SCIP_LEADERRULE_LASTINORBIT = 1 + SCIP_LEADERRULE_MAXCONFLICTSINORBIT = 2 +end + +const SCIP_LEADERRULE = SCIP_LeaderRule + +@enum SCIP_LeaderTiebreakRule::UInt32 begin + SCIP_LEADERTIEBREAKRULE_MINORBIT = 0 + SCIP_LEADERTIEBREAKRULE_MAXORBIT = 1 + SCIP_LEADERTIEBREAKRULE_MAXCONFLICTSINORBIT = 2 +end + +@enum SCIP_SSTType::UInt32 begin + SCIP_SSTTYPE_BINARY = 1 + SCIP_SSTTYPE_INTEGER = 2 + SCIP_SSTTYPE_CONTINUOUS = 4 +end + +const SCIP_SSTTYPE = SCIP_SSTType + +@enum SCIP_OrbitopeType::UInt32 begin + SCIP_ORBITOPETYPE_FULL = 0 + SCIP_ORBITOPETYPE_PARTITIONING = 1 + SCIP_ORBITOPETYPE_PACKING = 2 +end + +const SCIP_ORBITOPETYPE = SCIP_OrbitopeType + +function SCIPincludeConshdlrOrbitope(scip) + ccall((:SCIPincludeConshdlrOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateConsOrbitope(scip, cons, name, vars, orbitopetype, nrows, ncols, resolveprop, ismodelcons, checkpporbitope, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{Ptr{SCIP_VAR}}}, SCIP_ORBITOPETYPE, Cint, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, vars, orbitopetype, nrows, ncols, resolveprop, ismodelcons, checkpporbitope, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicOrbitope(scip, cons, name, vars, orbitopetype, nrows, ncols, resolveprop, ismodelcons, checkpporbitope) + ccall((:SCIPcreateConsBasicOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{Ptr{SCIP_VAR}}}, SCIP_ORBITOPETYPE, Cint, Cint, Cuint, Cuint, Cuint), scip, cons, name, vars, orbitopetype, nrows, ncols, resolveprop, ismodelcons, checkpporbitope) +end + +function SCIPincludeConshdlrPseudoboolean(scip) + ccall((:SCIPincludeConshdlrPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +@enum SCIP_LinearConsType::Int32 begin + SCIP_LINEARCONSTYPE_INVALIDCONS = -1 + SCIP_LINEARCONSTYPE_LINEAR = 0 + SCIP_LINEARCONSTYPE_LOGICOR = 1 + SCIP_LINEARCONSTYPE_KNAPSACK = 2 + SCIP_LINEARCONSTYPE_SETPPC = 3 +end + +const SCIP_LINEARCONSTYPE = SCIP_LinearConsType + +function SCIPcreateConsPseudobooleanWithConss(scip, cons, name, lincons, linconstype, andconss, andcoefs, nandconss, indvar, weight, issoftcons, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsPseudobooleanWithConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_CONS}, SCIP_LINEARCONSTYPE, Ptr{Ptr{SCIP_CONS}}, Ptr{Cdouble}, Cint, Ptr{SCIP_VAR}, Cdouble, Cuint, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, lincons, linconstype, andconss, andcoefs, nandconss, indvar, weight, issoftcons, 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, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cdouble}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_VAR}, Cdouble, Cuint, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, linvars, nlinvars, linvals, terms, nterms, ntermvars, termvals, indvar, weight, issoftcons, 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, lhs, rhs) + ccall((:SCIPcreateConsBasicPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cdouble}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_VAR}, Cdouble, Cuint, Cdouble, Cdouble), scip, cons, name, linvars, nlinvars, linvals, terms, nterms, ntermvars, termvals, indvar, weight, issoftcons, 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 + +function SCIPincludeConshdlrSetppc(scip) + ccall((:SCIPincludeConshdlrSetppc, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +@enum SCIP_SetppcType::UInt32 begin + SCIP_SETPPCTYPE_PARTITIONING = 0 + SCIP_SETPPCTYPE_PACKING = 1 + SCIP_SETPPCTYPE_COVERING = 2 +end + +const SCIP_SETPPCTYPE = SCIP_SetppcType + +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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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 SCIPcreateRowSetppc(scip, cons) + ccall((:SCIPcreateRowSetppc, libscip), SCIP_RETCODE, (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 + +function SCIPcleanupConssSetppc(scip, onlychecked, infeasible, naddconss, ndelconss, nchgcoefs, nfixedvars) + ccall((:SCIPcleanupConssSetppc, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, onlychecked, infeasible, naddconss, ndelconss, nchgcoefs, nfixedvars) +end + +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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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), Cuint, (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{Cuint}, Ptr{Cuint}), scip, conshdlr, sol, changed, success) +end + +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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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 + +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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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{Cuint}), 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 + +function SCIPincludeConshdlrSymresack(scip) + ccall((:SCIPincludeConshdlrSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateSymbreakCons(scip, cons, name, perm, vars, nvars, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateSymbreakCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, perm, vars, nvars, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsSymresack(scip, cons, name, perm, vars, nvars, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall((:SCIPcreateConsSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, perm, vars, nvars, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +end + +function SCIPcreateConsBasicSymresack(scip, cons, name, perm, vars, nvars, ismodelcons) + ccall((:SCIPcreateConsBasicSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint), scip, cons, name, perm, vars, nvars, ismodelcons) +end + +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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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 + +function SCIPcreateRowVarbound(scip, cons) + ccall((:SCIPcreateRowVarbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPcleanupConssVarbound(scip, onlychecked, infeasible, naddconss, ndelconss, nchgbds) + ccall((:SCIPcleanupConssVarbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, onlychecked, infeasible, naddconss, ndelconss, nchgbds) +end + +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}}, Ptr{Cchar}, Cuint, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cuint, 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), Cuint, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) +end + +function SCIPincludeConshdlrComponents(scip) + ccall((:SCIPincludeConshdlrComponents, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeDispDefault(scip) + ccall((:SCIPincludeDispDefault, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPdialogExecMenu(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecMenu, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecMenuLazy(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecMenuLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecChangeAddCons(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecChangeAddCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecChangeBounds(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecChangeBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecChangeFreetransproblem(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecChangeFreetransproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecChangeObjSense(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecChangeObjSense, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecChecksol(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecChecksol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecCliquegraph(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecCliquegraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayBenders(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayBranching(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayBranching, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayCompression(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayConflict(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayConshdlrs(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayConshdlrs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayDisplaycols(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayDisplaycols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayExprhdlrs(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayExprhdlrs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayCutselectors(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayCutselectors, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayHeuristics(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayIIS(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayIIS, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayMemory(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayMemory, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayNodeselectors(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayNodeselectors, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayNlpi(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayParameters(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayParameters, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayPresolvers(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayPresolvers, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayPricers(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayPricers, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayProblem(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayPropagators(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayPropagators, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayReaders(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayReaders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayRelaxators(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayRelaxators, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplaySeparators(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplaySeparators, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplaySolution(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplaySolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayFiniteSolution(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayFiniteSolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayDualSolution(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayDualSolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplaySolutionPool(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplaySolutionPool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplaySubproblem(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplaySubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplaySubSolution(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplaySubSolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayStatistics(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplaySymmetry(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplaySymmetry, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayReoptStatistics(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayReoptStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayTransproblem(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayTransproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayValue(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayValue, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayVarbranchstatistics(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayVarbranchstatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayLPSolutionQuality(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayLPSolutionQuality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayTranssolution(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayTranssolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecHelp(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecHelp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecFree(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecNewstart(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecNewstart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecTransform(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecTransform, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecOptimize(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecOptimize, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecConcurrentOpt(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecConcurrentOpt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecPresolve(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecPresolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecIIS(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecIIS, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecQuit(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecQuit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecRead(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecRead, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetDefault(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetLoad(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetLoad, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetSave(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetSave, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetDiffsave(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetDiffsave, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetParam(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogDescSetParam(scip, dialog) + ccall((:SCIPdialogDescSetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) +end + +function SCIPdialogExecFixParam(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecFixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogDescFixParam(scip, dialog) + ccall((:SCIPdialogDescFixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) +end + +function SCIPdialogExecSetBranchingDirection(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetBranchingDirection, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetBranchingPriority(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetBranchingPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetHeuristicsAggressive(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetHeuristicsAggressive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetHeuristicsDefault(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetHeuristicsDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetHeuristicsFast(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetHeuristicsFast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetHeuristicsOff(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetHeuristicsOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetPresolvingAggressive(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetPresolvingAggressive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetPresolvingDefault(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetPresolvingDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetPresolvingFast(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetPresolvingFast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetPresolvingOff(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetPresolvingOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetSeparatingAggressive(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetSeparatingAggressive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetSeparatingDefault(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetSeparatingDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetSeparatingFast(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetSeparatingFast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetSeparatingOff(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetSeparatingOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetEmphasisCounter(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetEmphasisCounter, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetEmphasisCpsolver(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetEmphasisCpsolver, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetEmphasisEasycip(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetEmphasisEasycip, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetEmphasisFeasibility(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetEmphasisFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetEmphasisHardlp(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetEmphasisHardlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetEmphasisOptimality(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetEmphasisOptimality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetEmphasisNumerics(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetEmphasisNumerics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetEmphasisBenchmark(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetEmphasisBenchmark, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecSetLimitsObjective(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecSetLimitsObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPdialogExecDisplayLinearConsClassification(scip, dialog, dialoghdlr, nextdialog) + ccall((:SCIPdialogExecDisplayLinearConsClassification, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) +end + +function SCIPcreateRootDialog(scip, root) + ccall((:SCIPcreateRootDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), scip, root) +end + +function SCIPincludeDialogDefaultBasic(scip) + ccall((:SCIPincludeDialogDefaultBasic, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeDialogDefaultSet(scip) + ccall((:SCIPincludeDialogDefaultSet, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeDialogDefaultFix(scip) + ccall((:SCIPincludeDialogDefaultFix, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeEventHdlrEstim(scip) + ccall((:SCIPincludeEventHdlrEstim, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetTreesizeEstimation(scip) + ccall((:SCIPgetTreesizeEstimation, libscip), Cdouble, (Ptr{SCIP},), scip) +end + +function SCIPincludeEventHdlrSolvingphase(scip) + ccall((:SCIPincludeEventHdlrSolvingphase, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeEventHdlrSofttimelimit(scip) + ccall((:SCIPincludeEventHdlrSofttimelimit, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprAbs(scip, expr, child, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprAbs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) +end + +function SCIPisExprAbs(scip, expr) + ccall((:SCIPisExprAbs, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPincludeExprhdlrAbs(scip) + ccall((:SCIPincludeExprhdlrAbs, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeExprhdlrEntropy(scip) + ccall((:SCIPincludeExprhdlrEntropy, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprEntropy(scip, expr, child, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprEntropy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) +end + +function SCIPisExprEntropy(scip, expr) + ccall((:SCIPisExprEntropy, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPcreateExprExp(scip, expr, child, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprExp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) +end + +function SCIPisExprExp(scip, expr) + ccall((:SCIPisExprExp, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPincludeExprhdlrExp(scip) + ccall((:SCIPincludeExprhdlrExp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprLog(scip, expr, child, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprLog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) +end + +function SCIPisExprLog(scip, expr) + ccall((:SCIPisExprLog, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPincludeExprhdlrLog(scip) + ccall((:SCIPincludeExprhdlrLog, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprPow(scip, expr, child, exponent, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprPow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, exponent, ownercreate, ownercreatedata) +end + +function SCIPcreateExprSignpower(scip, expr, child, exponent, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprSignpower, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, exponent, ownercreate, ownercreatedata) +end + +function SCIPisExprSignpower(scip, expr) + ccall((:SCIPisExprSignpower, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPincludeExprhdlrPow(scip) + ccall((:SCIPincludeExprhdlrPow, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeExprhdlrSignpower(scip) + ccall((:SCIPincludeExprhdlrSignpower, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPaddSquareLinearization(scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) + ccall((:SCIPaddSquareLinearization, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) +end + +function SCIPaddSquareSecant(scip, sqrcoef, lb, ub, lincoef, linconstant, success) + ccall((:SCIPaddSquareSecant, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), scip, sqrcoef, lb, ub, lincoef, linconstant, success) +end + +function SCIPestimateRoot(scip, exponent, overestimate, xlb, xub, xref, constant, slope, islocal, success) + ccall((:SCIPestimateRoot, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cuint, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}), scip, exponent, overestimate, xlb, xub, xref, constant, slope, islocal, success) +end + +function SCIPincludeExprhdlrProduct(scip) + ccall((:SCIPincludeExprhdlrProduct, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprProduct(scip, expr, nchildren, children, coefficient, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprProduct, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Ptr{SCIP_EXPR}}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, nchildren, children, coefficient, ownercreate, ownercreatedata) +end + +function SCIPincludeExprhdlrSum(scip) + ccall((:SCIPincludeExprhdlrSum, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprSum(scip, expr, nchildren, children, coefficients, constant, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cdouble}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, nchildren, children, coefficients, constant, ownercreate, ownercreatedata) +end + +function SCIPsetConstantExprSum(expr, constant) + ccall((:SCIPsetConstantExprSum, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cdouble), expr, constant) +end + +function SCIPappendExprSumExpr(scip, expr, child, childcoef) + ccall((:SCIPappendExprSumExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}, Cdouble), scip, expr, child, childcoef) +end + +function SCIPmultiplyByConstantExprSum(expr, constant) + ccall((:SCIPmultiplyByConstantExprSum, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cdouble), expr, constant) +end + +function SCIPmultiplyBySumExprSum(scip, product, factor1, factor2, simplify, ownercreate, ownercreatedata) + ccall((:SCIPmultiplyBySumExprSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}, Cuint, Ptr{Cvoid}, Ptr{Cvoid}), scip, product, factor1, factor2, simplify, ownercreate, ownercreatedata) +end + +function SCIPpowerExprSum(scip, result, base, exponent, simplify, ownercreate, ownercreatedata) + ccall((:SCIPpowerExprSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Cint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}), scip, result, base, exponent, simplify, ownercreate, ownercreatedata) +end + +function SCIPincludeExprhdlrSin(scip) + ccall((:SCIPincludeExprhdlrSin, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeExprhdlrCos(scip) + ccall((:SCIPincludeExprhdlrCos, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprSin(scip, expr, child, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprSin, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) +end + +function SCIPcreateExprCos(scip, expr, child, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprCos, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) +end + +function SCIPisExprSin(scip, expr) + ccall((:SCIPisExprSin, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPisExprCos(scip, expr) + ccall((:SCIPisExprCos, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPincludeExprhdlrValue(scip) + ccall((:SCIPincludeExprhdlrValue, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprValue(scip, expr, value, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprValue, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, value, ownercreate, ownercreatedata) +end + +function SCIPincludeExprhdlrVar(scip) + ccall((:SCIPincludeExprhdlrVar, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprVar(scip, expr, var, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_VAR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, var, ownercreate, ownercreatedata) +end + +function SCIPincludeHeurActconsdiving(scip) + ccall((:SCIPincludeHeurActconsdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurAdaptivediving(scip) + ccall((:SCIPincludeHeurAdaptivediving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurBound(scip) + ccall((:SCIPincludeHeurBound, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurClique(scip) + ccall((:SCIPincludeHeurClique, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurCoefdiving(scip) + ccall((:SCIPincludeHeurCoefdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurCompletesol(scip) + ccall((:SCIPincludeHeurCompletesol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurConflictdiving(scip) + ccall((:SCIPincludeHeurConflictdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurCrossover(scip) + ccall((:SCIPincludeHeurCrossover, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurDins(scip) + ccall((:SCIPincludeHeurDins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurDistributiondiving(scip) + ccall((:SCIPincludeHeurDistributiondiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurDKS(scip) + ccall((:SCIPincludeHeurDKS, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurDps(scip) + ccall((:SCIPincludeHeurDps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurDualval(scip) + ccall((:SCIPincludeHeurDualval, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPapplyHeurDualval(scip, heur, result, refpoint) + ccall((:SCIPapplyHeurDualval, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Ptr{SCIP_SOL}), scip, heur, result, refpoint) +end + +function SCIPincludeHeurFarkasdiving(scip) + ccall((:SCIPincludeHeurFarkasdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurFeaspump(scip) + ccall((:SCIPincludeHeurFeaspump, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurFixandinfer(scip) + ccall((:SCIPincludeHeurFixandinfer, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurFracdiving(scip) + ccall((:SCIPincludeHeurFracdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurGins(scip) + ccall((:SCIPincludeHeurGins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurGuideddiving(scip) + ccall((:SCIPincludeHeurGuideddiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurIndicator(scip) + ccall((:SCIPincludeHeurIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPheurPassIndicator(scip, heur, nindconss, indconss, solcand, obj) + ccall((:SCIPheurPassIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Cuint}, Cdouble), scip, heur, nindconss, indconss, solcand, obj) +end + +function SCIPincludeHeurIndicatordiving(scip) + ccall((:SCIPincludeHeurIndicatordiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurIntdiving(scip) + ccall((:SCIPincludeHeurIntdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurIntshifting(scip) + ccall((:SCIPincludeHeurIntshifting, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurLinesearchdiving(scip) + ccall((:SCIPincludeHeurLinesearchdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurLocalbranching(scip) + ccall((:SCIPincludeHeurLocalbranching, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurLocks(scip) + ccall((:SCIPincludeHeurLocks, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPapplyLockFixings(scip, heurdata, cutoff, allrowsfulfilled) + ccall((:SCIPapplyLockFixings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEURDATA}, Ptr{Cuint}, Ptr{Cuint}), scip, heurdata, cutoff, allrowsfulfilled) +end + +function SCIPincludeHeurLpface(scip) + ccall((:SCIPincludeHeurLpface, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurAlns(scip) + ccall((:SCIPincludeHeurAlns, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurMultistart(scip) + ccall((:SCIPincludeHeurMultistart, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurMutation(scip) + ccall((:SCIPincludeHeurMutation, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurMpec(scip) + ccall((:SCIPincludeHeurMpec, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurNlpdiving(scip) + ccall((:SCIPincludeHeurNlpdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurObjpscostdiving(scip) + ccall((:SCIPincludeHeurObjpscostdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurOctane(scip) + ccall((:SCIPincludeHeurOctane, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurOfins(scip) + ccall((:SCIPincludeHeurOfins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurOneopt(scip) + ccall((:SCIPincludeHeurOneopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurPADM(scip) + ccall((:SCIPincludeHeurPADM, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurPscostdiving(scip) + ccall((:SCIPincludeHeurPscostdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurProximity(scip) + ccall((:SCIPincludeHeurProximity, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPapplyProximity(scip, heur, result, minimprove, nnodes, nlpiters, nusednodes, nusedlpiters, freesubscip) + ccall((:SCIPapplyProximity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cdouble, Clonglong, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}, Cuint), scip, heur, result, minimprove, nnodes, nlpiters, nusednodes, nusedlpiters, freesubscip) +end + +function SCIPdeleteSubproblemProximity(scip) + ccall((:SCIPdeleteSubproblemProximity, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurRandrounding(scip) + ccall((:SCIPincludeHeurRandrounding, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurRens(scip) + ccall((:SCIPincludeHeurRens, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPapplyRens(scip, heur, result, minfixingrate, minimprove, maxnodes, nstallnodes, startsol, binarybounds, uselprows) + ccall((:SCIPapplyRens, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cdouble, Cdouble, Clonglong, Clonglong, Cchar, Cuint, Cuint), scip, heur, result, minfixingrate, minimprove, maxnodes, nstallnodes, startsol, binarybounds, uselprows) +end + +function SCIPincludeHeurReoptsols(scip) + ccall((:SCIPincludeHeurReoptsols, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreoptsolsGetNCheckedsols(scip) + ccall((:SCIPreoptsolsGetNCheckedsols, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPreoptsolsGetNImprovingsols(scip) + ccall((:SCIPreoptsolsGetNImprovingsols, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurRepair(scip) + ccall((:SCIPincludeHeurRepair, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurRins(scip) + ccall((:SCIPincludeHeurRins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurRootsoldiving(scip) + ccall((:SCIPincludeHeurRootsoldiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurRounding(scip) + ccall((:SCIPincludeHeurRounding, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurScheduler(scip) + ccall((:SCIPincludeHeurScheduler, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurShiftandpropagate(scip) + ccall((:SCIPincludeHeurShiftandpropagate, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurShifting(scip) + ccall((:SCIPincludeHeurShifting, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurSimplerounding(scip) + ccall((:SCIPincludeHeurSimplerounding, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurSubNlp(scip) + ccall((:SCIPincludeHeurSubNlp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPapplyHeurSubNlp(scip, heur, result, refpoint, resultsol) + ccall((:SCIPapplyHeurSubNlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Ptr{SCIP_SOL}, Ptr{SCIP_SOL}), scip, heur, result, refpoint, resultsol) +end + +function SCIPupdateStartpointHeurSubNlp(scip, heur, solcand, violation) + ccall((:SCIPupdateStartpointHeurSubNlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}, Cdouble), scip, heur, solcand, violation) +end + +function SCIPgetStartCandidateHeurSubNlp(scip, heur) + ccall((:SCIPgetStartCandidateHeurSubNlp, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP}, Ptr{SCIP_HEUR}), scip, heur) +end + +function SCIPincludeHeurTrivial(scip) + ccall((:SCIPincludeHeurTrivial, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurTrivialnegation(scip) + ccall((:SCIPincludeHeurTrivialnegation, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurTrustregion(scip) + ccall((:SCIPincludeHeurTrustregion, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurTrySol(scip) + ccall((:SCIPincludeHeurTrySol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPheurPassSolTrySol(scip, heur, sol) + ccall((:SCIPheurPassSolTrySol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}), scip, heur, sol) +end + +function SCIPheurPassSolAddSol(scip, heur, sol) + ccall((:SCIPheurPassSolAddSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}), scip, heur, sol) +end + +function SCIPincludeHeurTwoopt(scip) + ccall((:SCIPincludeHeurTwoopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurUndercover(scip) + ccall((:SCIPincludeHeurUndercover, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcomputeCoverUndercover(scip, coversize, cover, timelimit, memorylimit, objlimit, globalbounds, onlyconvexify, coverand, coverbd, coverind, covernl, coveringobj, success) + ccall((:SCIPcomputeCoverUndercover, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cchar, Ptr{Cuint}), scip, coversize, cover, timelimit, memorylimit, objlimit, globalbounds, onlyconvexify, coverand, coverbd, coverind, covernl, coveringobj, success) +end + +function SCIPincludeHeurVbounds(scip) + ccall((:SCIPincludeHeurVbounds, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurVeclendiving(scip) + ccall((:SCIPincludeHeurVeclendiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeHeurZeroobj(scip) + ccall((:SCIPincludeHeurZeroobj, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPapplyZeroobj(scip, heur, result, minimprove, nnodes) + ccall((:SCIPapplyZeroobj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cdouble, Clonglong), scip, heur, result, minimprove, nnodes) +end + +function SCIPincludeHeurZirounding(scip) + ccall((:SCIPincludeHeurZirounding, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeIISfinderGreedy(scip) + ccall((:SCIPincludeIISfinderGreedy, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPiisGreedyMakeIrreducible(iis) + ccall((:SCIPiisGreedyMakeIrreducible, libscip), SCIP_RETCODE, (Ptr{SCIP_IIS},), iis) +end + +function SCIPincludeNlhdlrBilinear(scip) + ccall((:SCIPincludeNlhdlrBilinear, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetExprsBilinear(nlhdlr) + ccall((:SCIPgetExprsBilinear, libscip), Ptr{Ptr{SCIP_EXPR}}, (Ptr{SCIP_NLHDLR},), nlhdlr) +end + +function SCIPgetNExprsBilinear(nlhdlr) + ccall((:SCIPgetNExprsBilinear, libscip), Cint, (Ptr{SCIP_NLHDLR},), nlhdlr) +end + +function SCIPaddIneqBilinear(scip, nlhdlr, expr, xcoef, ycoef, constant, success) + ccall((:SCIPaddIneqBilinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLHDLR}, Ptr{SCIP_EXPR}, Cdouble, Cdouble, Cdouble, Ptr{Cuint}), scip, nlhdlr, expr, xcoef, ycoef, constant, 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{Cuint}), 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, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), 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, Cuint, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), 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, xcoef1, ycoef1, constant1, xcoef2, ycoef2, constant2, lincoefx, lincoefy, linconstant, success) + ccall((:SCIPcomputeBilinEnvelope2, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cuint, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, xcoef1, ycoef1, constant1, xcoef2, ycoef2, constant2, lincoefx, lincoefy, linconstant, success) +end + +function SCIPincludeNlhdlrConvex(scip) + ccall((:SCIPincludeNlhdlrConvex, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNlhdlrConcave(scip) + ccall((:SCIPincludeNlhdlrConcave, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPhasExprCurvature(scip, expr, curv, success, assumevarfixed) + ccall((:SCIPhasExprCurvature, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_EXPRCURV, Ptr{Cuint}, Ptr{SCIP_HASHMAP}), scip, expr, curv, success, assumevarfixed) +end + +function SCIPincludeNlhdlrDefault(scip) + ccall((:SCIPincludeNlhdlrDefault, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNlhdlrPerspective(scip) + ccall((:SCIPincludeNlhdlrPerspective, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNlhdlrQuadratic(scip) + ccall((:SCIPincludeNlhdlrQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNlhdlrQuotient(scip) + ccall((:SCIPincludeNlhdlrQuotient, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNlhdlrSignomial(scip) + ccall((:SCIPincludeNlhdlrSignomial, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNlhdlrSoc(scip) + ccall((:SCIPincludeNlhdlrSoc, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPisSOCNonlinear(scip, cons, compeigenvalues, success, sidetype, vars, offsets, transcoefs, transcoefsidx, termbegins, nvars, nterms) + ccall((:SCIPisSOCNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint, Ptr{Cuint}, Ptr{SCIP_SIDETYPE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}), scip, cons, compeigenvalues, success, sidetype, vars, offsets, transcoefs, transcoefsidx, termbegins, nvars, nterms) +end + +function SCIPfreeSOCArraysNonlinear(scip, vars, offsets, transcoefs, transcoefsidx, termbegins, nvars, nterms) + ccall((:SCIPfreeSOCArraysNonlinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Cint, Cint), scip, vars, offsets, transcoefs, transcoefsidx, termbegins, nvars, nterms) +end + +function SCIPincludeNodeselBfs(scip) + ccall((:SCIPincludeNodeselBfs, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNodeselBreadthfirst(scip) + ccall((:SCIPincludeNodeselBreadthfirst, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNodeselDfs(scip) + ccall((:SCIPincludeNodeselDfs, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNodeselEstimate(scip) + ccall((:SCIPincludeNodeselEstimate, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNodeselHybridestim(scip) + ccall((:SCIPincludeNodeselHybridestim, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNodeselUct(scip) + ccall((:SCIPincludeNodeselUct, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeNodeselRestartdfs(scip) + ccall((:SCIPincludeNodeselRestartdfs, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolBoundshift(scip) + ccall((:SCIPincludePresolBoundshift, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolConvertinttobin(scip) + ccall((:SCIPincludePresolConvertinttobin, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolDomcol(scip) + ccall((:SCIPincludePresolDomcol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolDualagg(scip) + ccall((:SCIPincludePresolDualagg, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolDualcomp(scip) + ccall((:SCIPincludePresolDualcomp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolDualinfer(scip) + ccall((:SCIPincludePresolDualinfer, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolGateextraction(scip) + ccall((:SCIPincludePresolGateextraction, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolImplics(scip) + ccall((:SCIPincludePresolImplics, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolImplint(scip) + ccall((:SCIPincludePresolImplint, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolInttobinary(scip) + ccall((:SCIPincludePresolInttobinary, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolMILP(scip) + ccall((:SCIPincludePresolMILP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolRedvub(scip) + ccall((:SCIPincludePresolRedvub, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolQPKKTref(scip) + ccall((:SCIPincludePresolQPKKTref, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolTrivial(scip) + ccall((:SCIPincludePresolTrivial, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolTworowbnd(scip) + ccall((:SCIPincludePresolTworowbnd, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolSparsify(scip) + ccall((:SCIPincludePresolSparsify, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolDualsparsify(scip) + ccall((:SCIPincludePresolDualsparsify, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePresolStuffing(scip) + ccall((:SCIPincludePresolStuffing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePropDualfix(scip) + ccall((:SCIPincludePropDualfix, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgenVBoundAdd(scip, genvboundprop, vars, var, coefs, ncoefs, coefcutoffbound, constant, boundtype) + ccall((:SCIPgenVBoundAdd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_VAR}, Ptr{Cdouble}, Cint, Cdouble, Cdouble, SCIP_BOUNDTYPE), scip, genvboundprop, vars, var, coefs, ncoefs, coefcutoffbound, constant, boundtype) +end + +function SCIPincludePropGenvbounds(scip) + ccall((:SCIPincludePropGenvbounds, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePropNlobbt(scip) + ccall((:SCIPincludePropNlobbt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePropObbt(scip) + ccall((:SCIPincludePropObbt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePropProbing(scip) + ccall((:SCIPincludePropProbing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPapplyProbingVar(scip, vars, nvars, probingpos, boundtype, bound, maxproprounds, impllbs, implubs, proplbs, propubs, cutoff) + ccall((:SCIPapplyProbingVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, SCIP_BOUNDTYPE, Cdouble, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), scip, vars, nvars, probingpos, boundtype, bound, maxproprounds, impllbs, implubs, proplbs, propubs, cutoff) +end + +function SCIPanalyzeDeductionsProbing(scip, probingvar, leftub, rightlb, nvars, vars, leftimpllbs, leftimplubs, leftproplbs, leftpropubs, rightimpllbs, rightimplubs, rightproplbs, rightpropubs, nfixedvars, naggrvars, nimplications, nchgbds, cutoff) + ccall((:SCIPanalyzeDeductionsProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}), scip, probingvar, leftub, rightlb, nvars, vars, leftimpllbs, leftimplubs, leftproplbs, leftpropubs, rightimpllbs, rightimplubs, rightproplbs, rightpropubs, nfixedvars, naggrvars, nimplications, nchgbds, cutoff) +end + +function SCIPincludePropPseudoobj(scip) + ccall((:SCIPincludePropPseudoobj, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPpropagateCutoffboundVar(scip, prop, var, cutoffbound, pseudoobjval, tightened) + ccall((:SCIPpropagateCutoffboundVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Cuint}), scip, prop, var, cutoffbound, pseudoobjval, tightened) +end + +function SCIPincludePropRedcost(scip) + ccall((:SCIPincludePropRedcost, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePropRootredcost(scip) + ccall((:SCIPincludePropRootredcost, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludePropSymmetry(scip) + ccall((:SCIPincludePropSymmetry, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetSymmetry(scip, npermvars, permvars, permvarmap, nperms, perms, permstrans, log10groupsize, binvaraffected, components, componentbegins, vartocomponent, ncomponents) + ccall((:SCIPgetSymmetry, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{SCIP_HASHMAP}}, Ptr{Cint}, Ptr{Ptr{Ptr{Cint}}}, Ptr{Ptr{Ptr{Cint}}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Cint}), scip, npermvars, permvars, permvarmap, nperms, perms, permstrans, log10groupsize, binvaraffected, components, componentbegins, vartocomponent, ncomponents) +end + +function SCIPgetSymmetryNGenerators(scip) + ccall((:SCIPgetSymmetryNGenerators, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPdisplaySymmetryGenerators(scip, prop) + ccall((:SCIPdisplaySymmetryGenerators, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}), scip, prop) +end + +function SCIPcreateSymOpNodeType(scip, opnodename, nodetype) + ccall((:SCIPcreateSymOpNodeType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), scip, opnodename, nodetype) +end + +function SCIPgetSymOpNodeType(scip, opnodename, nodetype) + ccall((:SCIPgetSymOpNodeType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), scip, opnodename, nodetype) +end + +function SCIPincludePropVbounds(scip) + ccall((:SCIPincludePropVbounds, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPisPropagatedVbounds(scip) + ccall((:SCIPisPropagatedVbounds, libscip), Cuint, (Ptr{SCIP},), scip) +end + +function SCIPexecPropVbounds(scip, force, result) + ccall((:SCIPexecPropVbounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{SCIP_RESULT}), scip, force, result) +end + +function SCIPincludeReaderBnd(scip) + ccall((:SCIPincludeReaderBnd, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderCcg(scip) + ccall((:SCIPincludeReaderCcg, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPwriteCcg(scip, file, name, transformed, vars, nvars, conss, nconss, result) + ccall((:SCIPwriteCcg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, transformed, vars, nvars, conss, nconss, result) +end + +function SCIPincludeReaderCip(scip) + ccall((:SCIPincludeReaderCip, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderCnf(scip) + ccall((:SCIPincludeReaderCnf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderCor(scip) + ccall((:SCIPincludeReaderCor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreadCor(scip, filename, result) + ccall((:SCIPreadCor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, filename, result) +end + +function SCIPfreeReaderdataCor(scip) + ccall((:SCIPfreeReaderdataCor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcorHasRead(reader) + ccall((:SCIPcorHasRead, libscip), Cuint, (Ptr{SCIP_READER},), reader) +end + +function SCIPcorGetNVarNames(reader) + ccall((:SCIPcorGetNVarNames, libscip), Cint, (Ptr{SCIP_READER},), reader) +end + +function SCIPcorGetNConsNames(reader) + ccall((:SCIPcorGetNConsNames, libscip), Cint, (Ptr{SCIP_READER},), reader) +end + +function SCIPcorGetVarName(reader, i) + ccall((:SCIPcorGetVarName, libscip), Ptr{Cchar}, (Ptr{SCIP_READER}, Cint), reader, i) +end + +function SCIPcorGetConsName(reader, i) + ccall((:SCIPcorGetConsName, libscip), Ptr{Cchar}, (Ptr{SCIP_READER}, Cint), reader, i) +end + +function SCIPincludeReaderDec(scip) + ccall((:SCIPincludeReaderDec, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderDiff(scip) + ccall((:SCIPincludeReaderDiff, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreadDiff(scip, reader, filename, result) + ccall((:SCIPreadDiff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, reader, filename, result) +end + +function SCIPincludeReaderFix(scip) + ccall((:SCIPincludeReaderFix, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderFzn(scip) + ccall((:SCIPincludeReaderFzn, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPprintSolReaderFzn(scip, sol, file) + ccall((:SCIPprintSolReaderFzn, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), scip, sol, file) +end + +function SCIPincludeReaderGms(scip) + ccall((:SCIPincludeReaderGms, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPwriteGms(scip, file, name, transformed, objsense, objscale, objoffset, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) + ccall((:SCIPwriteGms, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, transformed, objsense, objscale, objoffset, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) +end + +function SCIPincludeReaderLp(scip) + ccall((:SCIPincludeReaderLp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreadLp(scip, reader, filename, result) + ccall((:SCIPreadLp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, reader, filename, result) +end + +function SCIPwriteLp(scip, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) + ccall((:SCIPwriteLp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) +end + +function SCIPincludeReaderMps(scip) + ccall((:SCIPincludeReaderMps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreadMps(scip, reader, filename, result, varnames, consnames, varnamessize, consnamessize, nvarnames, nconsnames) + ccall((:SCIPreadMps, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}, Ptr{Ptr{Ptr{Cchar}}}, Ptr{Ptr{Ptr{Cchar}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, reader, filename, result, varnames, consnames, varnamessize, consnamessize, nvarnames, nconsnames) +end + +function SCIPwriteMps(scip, reader, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, result) + ccall((:SCIPwriteMps, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, reader, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, result) +end + +function SCIPincludeReaderMst(scip) + ccall((:SCIPincludeReaderMst, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderNl(scip) + ccall((:SCIPincludeReaderNl, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPwriteSolutionNl(scip) + ccall((:SCIPwriteSolutionNl, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderOpb(scip) + ccall((:SCIPincludeReaderOpb, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreadOpb(scip, reader, filename, result) + ccall((:SCIPreadOpb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, reader, filename, result) +end + +function SCIPwriteOpb(scip, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, genericnames, result) + ccall((:SCIPwriteOpb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Cuint, Ptr{SCIP_RESULT}), scip, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, genericnames, result) +end + +function SCIPincludeReaderOsil(scip) + ccall((:SCIPincludeReaderOsil, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderPip(scip) + ccall((:SCIPincludeReaderPip, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreadPip(scip, reader, filename, result) + ccall((:SCIPreadPip, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, reader, filename, result) +end + +function SCIPwritePip(scip, file, name, transformed, objsense, objscale, objoffset, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) + ccall((:SCIPwritePip, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, transformed, objsense, objscale, objoffset, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) +end + +function SCIPincludeReaderPpm(scip) + ccall((:SCIPincludeReaderPpm, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPwritePpm(scip, file, name, readerdata, transformed, vars, nvars, conss, nconss, result) + ccall((:SCIPwritePpm, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Ptr{SCIP_READERDATA}, Cuint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, readerdata, transformed, vars, nvars, conss, nconss, result) +end + +function SCIPincludeReaderPbm(scip) + ccall((:SCIPincludeReaderPbm, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPwritePbm(scip, file, name, readerdata, transformed, nvars, conss, nconss, result) + ccall((:SCIPwritePbm, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Ptr{SCIP_READERDATA}, Cuint, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, readerdata, transformed, nvars, conss, nconss, result) +end + +function SCIPincludeReaderRlp(scip) + ccall((:SCIPincludeReaderRlp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderSmps(scip) + ccall((:SCIPincludeReaderSmps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderSol(scip) + ccall((:SCIPincludeReaderSol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderSto(scip) + ccall((:SCIPincludeReaderSto, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreadSto(scip, filename, result) + ccall((:SCIPreadSto, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, filename, result) +end + +function SCIPstoGetNScenarios(scip) + ccall((:SCIPstoGetNScenarios, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPfreeReaderdataSto(scip) + ccall((:SCIPfreeReaderdataSto, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderTim(scip) + ccall((:SCIPincludeReaderTim, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPreadTim(scip, filename, result) + ccall((:SCIPreadTim, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, filename, result) +end + +function SCIPfreeReaderdataTim(scip) + ccall((:SCIPfreeReaderdataTim, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPtimHasRead(reader) + ccall((:SCIPtimHasRead, libscip), Cuint, (Ptr{SCIP_READER},), reader) +end + +function SCIPtimGetNStages(scip) + ccall((:SCIPtimGetNStages, libscip), Cint, (Ptr{SCIP},), scip) +end + +function SCIPtimGetStageName(scip, stagenum) + ccall((:SCIPtimGetStageName, libscip), Ptr{Cchar}, (Ptr{SCIP}, Cint), scip, stagenum) +end + +function SCIPtimConsGetStageName(scip, consname) + ccall((:SCIPtimConsGetStageName, libscip), Ptr{Cchar}, (Ptr{SCIP}, Ptr{Cchar}), scip, consname) +end + +function SCIPtimFindStage(scip, stage) + ccall((:SCIPtimFindStage, libscip), Cint, (Ptr{SCIP}, Ptr{Cchar}), scip, stage) +end + +function SCIPtimGetStageVars(scip, stagenum) + ccall((:SCIPtimGetStageVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP}, Cint), scip, stagenum) +end + +function SCIPtimGetStageConss(scip, stagenum) + ccall((:SCIPtimGetStageConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP}, Cint), scip, stagenum) +end + +function SCIPtimGetStageNVars(scip, stagenum) + ccall((:SCIPtimGetStageNVars, libscip), Cint, (Ptr{SCIP}, Cint), scip, stagenum) +end + +function SCIPtimGetStageNConss(scip, stagenum) + ccall((:SCIPtimGetStageNConss, libscip), Cint, (Ptr{SCIP}, Cint), scip, stagenum) +end + +function SCIPincludeReaderWbo(scip) + ccall((:SCIPincludeReaderWbo, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeReaderZpl(scip) + ccall((:SCIPincludeReaderZpl, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaEccuts(scip) + ccall((:SCIPincludeSepaEccuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaCGMIP(scip) + ccall((:SCIPincludeSepaCGMIP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaClique(scip) + ccall((:SCIPincludeSepaClique, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaClosecuts(scip) + ccall((:SCIPincludeSepaClosecuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPsetBasePointClosecuts(scip, sol) + ccall((:SCIPsetBasePointClosecuts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) +end + +function SCIPincludeSepaAggregation(scip) + ccall((:SCIPincludeSepaAggregation, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaConvexproj(scip) + ccall((:SCIPincludeSepaConvexproj, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaDisjunctive(scip) + ccall((:SCIPincludeSepaDisjunctive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaFlower(scip) + ccall((:SCIPincludeSepaFlower, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaGauge(scip) + ccall((:SCIPincludeSepaGauge, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaGomory(scip) + ccall((:SCIPincludeSepaGomory, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaImpliedbounds(scip) + ccall((:SCIPincludeSepaImpliedbounds, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaInterminor(scip) + ccall((:SCIPincludeSepaInterminor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaIntobj(scip) + ccall((:SCIPincludeSepaIntobj, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaLagromory(scip) + ccall((:SCIPincludeSepaLagromory, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaMcf(scip) + ccall((:SCIPincludeSepaMcf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaMinor(scip) + ccall((:SCIPincludeSepaMinor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaMixing(scip) + ccall((:SCIPincludeSepaMixing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaOddcycle(scip) + ccall((:SCIPincludeSepaOddcycle, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaRapidlearning(scip) + ccall((:SCIPincludeSepaRapidlearning, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaRlt(scip) + ccall((:SCIPincludeSepaRlt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeSepaZerohalf(scip) + ccall((:SCIPincludeSepaZerohalf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPprocessShellArguments(scip, argc, argv, defaultsetname) + ccall((:SCIPprocessShellArguments, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}), scip, argc, argv, defaultsetname) +end + +function SCIPrunShell(argc, argv, defaultsetname) + ccall((:SCIPrunShell, libscip), SCIP_RETCODE, (Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}), argc, argv, defaultsetname) +end + +function SCIPgetSymInferredVarType(var) + ccall((:SCIPgetSymInferredVarType, libscip), SCIP_VARTYPE, (Ptr{SCIP_VAR},), var) +end + +function SCIPcomputeOrbitsSym(scip, issigned, permvars, npermvars, perms, nperms, orbits, orbitbegins, norbits) + ccall((:SCIPcomputeOrbitsSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{Cint}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, issigned, permvars, npermvars, perms, nperms, orbits, orbitbegins, norbits) +end + +function SCIPcomputeOrbitsFilterSym(scip, npermvars, permstrans, nperms, inactiveperms, orbits, orbitbegins, norbits, components, componentbegins, vartocomponent, componentblocked, ncomponents, nmovedpermvars) + ccall((:SCIPcomputeOrbitsFilterSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{Cint}}, Cint, Ptr{UInt8}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Cint, Cint), scip, npermvars, permstrans, nperms, inactiveperms, orbits, orbitbegins, norbits, components, componentbegins, vartocomponent, componentblocked, ncomponents, nmovedpermvars) +end + +function SCIPcomputeOrbitsComponentsSym(scip, npermvars, permstrans, nperms, components, componentbegins, vartocomponent, ncomponents, orbits, orbitbegins, norbits, varorbitmap) + ccall((:SCIPcomputeOrbitsComponentsSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{Cint}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, npermvars, permstrans, nperms, components, componentbegins, vartocomponent, ncomponents, orbits, orbitbegins, norbits, varorbitmap) +end + +function SCIPcomputeOrbitVar(scip, npermvars, perms, permstrans, components, componentbegins, ignoredvars, varfound, varidx, component, orbit, orbitsize) + ccall((:SCIPcomputeOrbitVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt8}, Ptr{UInt8}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), scip, npermvars, perms, permstrans, components, componentbegins, ignoredvars, varfound, varidx, component, orbit, orbitsize) +end + +function SCIPisInvolutionPerm(perm, vars, nvars, ntwocyclesperm, nbincyclesperm, earlytermination) + ccall((:SCIPisInvolutionPerm, libscip), SCIP_RETCODE, (Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}, Cuint), perm, vars, nvars, ntwocyclesperm, nbincyclesperm, earlytermination) +end + +function SCIPdetermineNVarsAffectedSym(scip, perms, nperms, permvars, npermvars, nvarsaffected) + ccall((:SCIPdetermineNVarsAffectedSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Cint}}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}), scip, perms, nperms, permvars, npermvars, nvarsaffected) +end + +function SCIPcomputeComponentsSym(scip, symtype, perms, nperms, permvars, npermvars, transposed, components, componentbegins, vartocomponent, componentblocked, ncomponents) + ccall((:SCIPcomputeComponentsSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, SYM_SYMTYPE, Ptr{Ptr{Cint}}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cuint}}, Ptr{Cint}), scip, symtype, perms, nperms, permvars, npermvars, transposed, components, componentbegins, vartocomponent, componentblocked, ncomponents) +end + +function SCIPextendSubOrbitope(suborbitope, nrows, nfilledcols, coltoextend, perm, leftextension, nusedelems, permvars, rowisbinary, success, infeasible) + ccall((:SCIPextendSubOrbitope, libscip), SCIP_RETCODE, (Ptr{Ptr{Cint}}, Cint, Cint, Cint, Ptr{Cint}, Cuint, Ptr{Ptr{Cint}}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt8}, Ptr{Cuint}, Ptr{Cuint}), suborbitope, nrows, nfilledcols, coltoextend, perm, leftextension, nusedelems, permvars, rowisbinary, success, infeasible) +end + +function SCIPgenerateOrbitopeVarsMatrix(scip, vars, nrows, ncols, permvars, npermvars, orbitopevaridx, columnorder, nusedelems, rowisbinary, infeasible, storelexorder, lexorder, nvarsorder, maxnvarsorder) + ccall((:SCIPgenerateOrbitopeVarsMatrix, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Cint, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt8}, Ptr{Cuint}, Cuint, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}), scip, vars, nrows, ncols, permvars, npermvars, orbitopevaridx, columnorder, nusedelems, rowisbinary, infeasible, storelexorder, lexorder, nvarsorder, maxnvarsorder) +end + +function SCIPisPackingPartitioningOrbitope(scip, vars, nrows, ncols, pprows, npprows, type) + ccall((:SCIPisPackingPartitioningOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Cint, Cint, Ptr{Ptr{Cuint}}, Ptr{Cint}, Ptr{SCIP_ORBITOPETYPE}), scip, vars, nrows, ncols, pprows, npprows, type) +end + +function SCIPdetectSingleOrDoubleLexMatrices(scip, detectsinglelex, perms, nperms, permlen, success, isorbitope, lexmatrix, nrows, ncols, lexrowsbegin, lexcolsbegin, nrowmatrices, ncolmatrices) + ccall((:SCIPdetectSingleOrDoubleLexMatrices, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Ptr{Cint}}, Cint, Cint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Ptr{Cint}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}), scip, detectsinglelex, perms, nperms, permlen, success, isorbitope, lexmatrix, nrows, ncols, lexrowsbegin, lexcolsbegin, nrowmatrices, ncolmatrices) +end + +function SCIPsymEQ(scip, val1, val2) + ccall((:SCIPsymEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPsymLE(scip, val1, val2) + ccall((:SCIPsymLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPsymGE(scip, val1, val2) + ccall((:SCIPsymGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPsymLT(scip, val1, val2) + ccall((:SCIPsymLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPsymGT(scip, val1, val2) + ccall((:SCIPsymGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) +end + +function SCIPincludeTableDefault(scip) + ccall((:SCIPincludeTableDefault, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeConcurrentScipSolvers(scip) + ccall((:SCIPincludeConcurrentScipSolvers, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeBendersDefault(scip) + ccall((:SCIPincludeBendersDefault, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateBendersDefault(scip, subproblems, nsubproblems) + ccall((:SCIPcreateBendersDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP}}, Cint), scip, subproblems, nsubproblems) +end + +function SCIPincludeRelaxBenders(scip) + ccall((:SCIPincludeRelaxBenders, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetMasterProblemRelaxBenders(scip) + ccall((:SCIPgetMasterProblemRelaxBenders, libscip), Ptr{SCIP}, (Ptr{SCIP},), scip) +end + +function SCIPincludeCutselHybrid(scip) + ccall((:SCIPincludeCutselHybrid, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPselectCutsHybrid(scip, cuts, forcedcuts, randnumgen, goodscorefac, badscorefac, goodmaxparall, maxparall, dircutoffdistweight, efficacyweight, objparalweight, intsupportweight, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) + ccall((:SCIPselectCutsHybrid, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_RANDNUMGEN}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, Cint, Ptr{Cint}), scip, cuts, forcedcuts, randnumgen, goodscorefac, badscorefac, goodmaxparall, maxparall, dircutoffdistweight, efficacyweight, objparalweight, intsupportweight, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) +end + +function SCIPincludeCutselDynamic(scip) + ccall((:SCIPincludeCutselDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPselectCutsDynamic(scip, cuts, forcedcuts, randnumgen, filtermode, mingain, maxparall, dircutoffdistweight, efficacyweight, objparalweight, intsupportweight, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) + ccall((:SCIPselectCutsDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_RANDNUMGEN}, Cchar, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, Cint, Ptr{Cint}), scip, cuts, forcedcuts, randnumgen, filtermode, mingain, maxparall, dircutoffdistweight, efficacyweight, objparalweight, intsupportweight, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) +end + +function SCIPincludeCutselEnsemble(scip) + ccall((:SCIPincludeCutselEnsemble, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPselectCutsEnsemble(scip, cuts, forcedcuts, cutseldata, root, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) + ccall((:SCIPselectCutsEnsemble, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CUTSELDATA}, Cuint, Cint, Cint, Cint, Ptr{Cint}), scip, cuts, forcedcuts, cutseldata, root, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) +end + +function SCIPincludeExprhdlrVaridx(scip) + ccall((:SCIPincludeExprhdlrVaridx, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPcreateExprVaridx(scip, expr, varidx, ownercreate, ownercreatedata) + ccall((:SCIPcreateExprVaridx, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, varidx, ownercreate, ownercreatedata) +end + +function SCIPisExprVaridx(scip, expr) + ccall((:SCIPisExprVaridx, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) +end + +function SCIPgetIndexExprVaridx(expr) + ccall((:SCIPgetIndexExprVaridx, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPsetIndexExprVaridx(expr, newindex) + ccall((:SCIPsetIndexExprVaridx, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint), expr, newindex) +end + +function SCIPincludeNlpSolverIpopt(scip) + ccall((:SCIPincludeNlpSolverIpopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetSolverNameIpopt() + ccall((:SCIPgetSolverNameIpopt, libscip), Ptr{Cchar}, ()) +end + +function SCIPgetSolverDescIpopt() + ccall((:SCIPgetSolverDescIpopt, libscip), Ptr{Cchar}, ()) +end + +function SCIPisIpoptAvailableIpopt() + ccall((:SCIPisIpoptAvailableIpopt, libscip), Cuint, ()) +end + +function SCIPgetNlpiOracleIpopt(nlpiproblem) + ccall((:SCIPgetNlpiOracleIpopt, libscip), Ptr{Cvoid}, (Ptr{SCIP_NLPIPROBLEM},), nlpiproblem) +end + +function SCIPcallLapackDsyevIpopt(computeeigenvectors, N, a, w) + ccall((:SCIPcallLapackDsyevIpopt, libscip), SCIP_RETCODE, (Cuint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), computeeigenvectors, N, a, w) +end + +function SCIPsolveLinearEquationsIpopt(N, A, b, x, success) + ccall((:SCIPsolveLinearEquationsIpopt, libscip), SCIP_RETCODE, (Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), N, A, b, x, success) +end + +function SCIPincludeNlpSolverFilterSQP(scip) + ccall((:SCIPincludeNlpSolverFilterSQP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPgetSolverNameFilterSQP() + ccall((:SCIPgetSolverNameFilterSQP, libscip), Ptr{Cchar}, ()) +end + +function SCIPgetSolverDescFilterSQP() + ccall((:SCIPgetSolverDescFilterSQP, libscip), Ptr{Cchar}, ()) +end + +function SCIPisFilterSQPAvailableFilterSQP() + ccall((:SCIPisFilterSQPAvailableFilterSQP, libscip), Cuint, ()) +end + +function SCIPincludeNlpSolverWorhp(scip, useip) + ccall((:SCIPincludeNlpSolverWorhp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, useip) +end + +function SCIPgetSolverNameWorhp() + ccall((:SCIPgetSolverNameWorhp, libscip), Ptr{Cchar}, ()) +end + +function SCIPgetSolverDescWorhp() + ccall((:SCIPgetSolverDescWorhp, libscip), Ptr{Cchar}, ()) +end + +function SCIPisWorhpAvailableWorhp() + ccall((:SCIPisWorhpAvailableWorhp, libscip), Cuint, ()) +end + +function SCIPincludeNlpSolverConopt(scip) + ccall((:SCIPincludeNlpSolverConopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPsetLicenseConopt(nlpi, integer_1, integer_2, integer_3, text) + ccall((:SCIPsetLicenseConopt, libscip), Cvoid, (Ptr{SCIP_NLPI}, Cint, Cint, Cint, Ptr{Cchar}), nlpi, integer_1, integer_2, integer_3, text) +end + +function SCIPgetSolverNameConopt() + ccall((:SCIPgetSolverNameConopt, libscip), Ptr{Cchar}, ()) +end + +function SCIPgetSolverDescConopt() + ccall((:SCIPgetSolverDescConopt, libscip), Ptr{Cchar}, ()) +end + +function SCIPisConoptAvailableConopt() + ccall((:SCIPisConoptAvailableConopt, libscip), Cuint, ()) +end + +function SCIPincludeNlpSolverAll(scip) + ccall((:SCIPincludeNlpSolverAll, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +function SCIPincludeDefaultPlugins(scip) + ccall((:SCIPincludeDefaultPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) +end + +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), Ptr{Cchar}, (Ptr{SCIP_BANDITVTABLE},), banditvtable) +end + +function SCIPbanditGetRandnumgen(bandit) + ccall((:SCIPbanditGetRandnumgen, libscip), Ptr{SCIP_RANDNUMGEN}, (Ptr{SCIP_BANDIT},), bandit) +end + +function SCIPbanditGetNActions(bandit) + ccall((:SCIPbanditGetNActions, libscip), Cint, (Ptr{SCIP_BANDIT},), bandit) +end + +function SCIPcreateBanditEpsgreedy(scip, epsgreedy, priorities, eps, usemodification, preferrecent, decayfactor, avglim, nactions, initseed) + ccall((:SCIPcreateBanditEpsgreedy, libscip), Cint, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, Cuint, Cuint, Cdouble, Cint, Cint, Cuint), scip, epsgreedy, priorities, eps, usemodification, 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 + +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, Cuint), 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 + +function SCIPcreateBanditExp3IX(scip, exp3ix, priorities, nactions, initseed) + ccall((:SCIPcreateBanditExp3IX, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cint, Cuint), scip, exp3ix, priorities, nactions, initseed) +end + +function SCIPgetProbabilityExp3IX(exp3ix, action) + ccall((:SCIPgetProbabilityExp3IX, libscip), Cdouble, (Ptr{SCIP_BANDIT}, Cint), exp3ix, action) +end + +function SCIPcreateBanditUcb(scip, ucb, priorities, alpha, nactions, initseed) + ccall((:SCIPcreateBanditUcb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, Cint, Cuint), 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 + +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), Ptr{Cchar}, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetDesc(benders) + ccall((:SCIPbendersGetDesc, libscip), Ptr{Cchar}, (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 SCIPbendersGetNStrengthenCutsFound(benders) + ccall((:SCIPbendersGetNStrengthenCutsFound, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetNStrengthenCalls(benders) + ccall((:SCIPbendersGetNStrengthenCalls, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetNStrengthenFails(benders) + ccall((:SCIPbendersGetNStrengthenFails, 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), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersIsActive(benders) + ccall((:SCIPbendersIsActive, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersOnlyCheckConvexRelax(benders, subscipsoff) + ccall((:SCIPbendersOnlyCheckConvexRelax, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cuint), benders, subscipsoff) +end + +function SCIPbendersGetNLPParam(benders) + ccall((:SCIPbendersGetNLPParam, libscip), SCIP_NLPPARAM, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersCutLP(benders) + ccall((:SCIPbendersCutLP, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersCutPseudo(benders) + ccall((:SCIPbendersCutPseudo, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersCutRelaxation(benders) + ccall((:SCIPbendersCutRelaxation, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersShareAuxVars(benders) + ccall((:SCIPbendersShareAuxVars, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSetSubproblemIsSetup(benders, probnumber, issetup) + ccall((:SCIPbendersSetSubproblemIsSetup, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cuint), benders, probnumber, issetup) +end + +function SCIPbendersSubproblemIsSetup(benders, probnumber) + ccall((:SCIPbendersSubproblemIsSetup, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbenderGetMasterAuxiliaryVar(benders) + ccall((:SCIPbenderGetMasterAuxiliaryVar, libscip), Ptr{SCIP_VAR}, (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 SCIPbendersGetSubproblemMasterVars(benders, probnumber) + ccall((:SCIPbendersGetSubproblemMasterVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersGetNSubproblemMasterVars(benders, probnumber) + ccall((:SCIPbendersGetNSubproblemMasterVars, libscip), Cint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersGetSubproblemMasterVarsData(benders, probnumber, vars, nvars, nbinvars, nintvars) + ccall((:SCIPbendersGetSubproblemMasterVarsData, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), benders, probnumber, vars, nvars, nbinvars, nintvars) +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 SCIPbendersGetNStoredCuts(benders) + ccall((:SCIPbendersGetNStoredCuts, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetStoredCutData(benders, cutidx, vars, vals, lhs, rhs, nvars) + ccall((:SCIPbendersGetStoredCutData, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERS}, Cint, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}), benders, cutidx, vars, vals, lhs, rhs, nvars) +end + +function SCIPbendersGetStoredCutOrigData(benders, cutidx, vars, vals, lhs, rhs, nvars, varssize) + ccall((:SCIPbendersGetStoredCutOrigData, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERS}, Cint, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint), benders, cutidx, vars, vals, lhs, rhs, nvars, varssize) +end + +function SCIPfindBenderscut(benders, name) + ccall((:SCIPfindBenderscut, libscip), Ptr{SCIP_BENDERSCUT}, (Ptr{SCIP_BENDERS}, Ptr{Cchar}), 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 SCIPbendersSolSlackVarsActive(benders, activeslack) + ccall((:SCIPbendersSolSlackVarsActive, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERS}, Ptr{Cuint}), benders, activeslack) +end + +function SCIPbendersSetSubproblemType(benders, probnumber, subprobtype) + ccall((:SCIPbendersSetSubproblemType, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, SCIP_BENDERSSUBTYPE), benders, probnumber, subprobtype) +end + +function SCIPbendersGetSubproblemType(benders, probnumber) + ccall((:SCIPbendersGetSubproblemType, libscip), SCIP_BENDERSSUBTYPE, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersSetSubproblemIsConvex(benders, probnumber, isconvex) + ccall((:SCIPbendersSetSubproblemIsConvex, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cuint), benders, probnumber, isconvex) +end + +function SCIPbendersSubproblemIsConvex(benders, probnumber) + ccall((:SCIPbendersSubproblemIsConvex, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersGetNConvexSubproblems(benders) + ccall((:SCIPbendersGetNConvexSubproblems, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSetSubproblemIsNonlinear(benders, probnumber, isnonlinear) + ccall((:SCIPbendersSetSubproblemIsNonlinear, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cuint), benders, probnumber, isnonlinear) +end + +function SCIPbendersSubproblemIsNonlinear(benders, probnumber) + ccall((:SCIPbendersSubproblemIsNonlinear, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersGetNNonlinearSubproblems(benders) + ccall((:SCIPbendersGetNNonlinearSubproblems, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSetMasterIsNonlinear(benders, isnonlinear) + ccall((:SCIPbendersSetMasterIsNonlinear, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cuint), benders, isnonlinear) +end + +function SCIPbendersMasterIsNonlinear(benders) + ccall((:SCIPbendersMasterIsNonlinear, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersGetObjectiveType(benders) + ccall((:SCIPbendersGetObjectiveType, libscip), SCIP_BENDERSOBJTYPE, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersInStrengthenRound(benders) + ccall((:SCIPbendersInStrengthenRound, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSubproblemsAreInfeasible(benders) + ccall((:SCIPbendersSubproblemsAreInfeasible, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) +end + +function SCIPbendersSolveSubproblemLP(scip, benders, probnumber, solvestatus, objective) + ccall((:SCIPbendersSolveSubproblemLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{SCIP_STATUS}, Ptr{Cdouble}), scip, benders, probnumber, solvestatus, objective) +end + +function SCIPbendersSolveSubproblemCIP(scip, benders, probnumber, solvestatus, solvecip) + ccall((:SCIPbendersSolveSubproblemCIP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{SCIP_STATUS}, Cuint), scip, benders, probnumber, solvestatus, 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, Cuint), benders, probnumber, isindep) +end + +function SCIPbendersSubproblemIsIndependent(benders, probnumber) + ccall((:SCIPbendersSubproblemIsIndependent, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +function SCIPbendersSubproblemIsEnabled(benders, probnumber) + ccall((:SCIPbendersSubproblemIsEnabled, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) +end + +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), Ptr{Cchar}, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutGetDesc(benderscut) + ccall((:SCIPbenderscutGetDesc, libscip), Ptr{Cchar}, (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), Cuint, (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 SCIPbenderscutIsLPCut(benderscut) + ccall((:SCIPbenderscutIsLPCut, libscip), Cuint, (Ptr{SCIP_BENDERSCUT},), benderscut) +end + +function SCIPbenderscutSetEnabled(benderscut, enabled) + ccall((:SCIPbenderscutSetEnabled, libscip), Cvoid, (Ptr{SCIP_BENDERSCUT}, Cuint), benderscut, enabled) +end + +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 SCIPbranchruleMarkExact(branchrule) + ccall((:SCIPbranchruleMarkExact, libscip), Cvoid, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetName(branchrule) + ccall((:SCIPbranchruleGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +function SCIPbranchruleGetDesc(branchrule) + ccall((:SCIPbranchruleGetDesc, libscip), Ptr{Cchar}, (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), Cuint, (Ptr{SCIP_BRANCHRULE},), branchrule) +end + +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(compr) + ccall((:SCIPcomprGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_COMPR},), compr) +end + +function SCIPcomprGetDesc(compr) + ccall((:SCIPcomprGetDesc, libscip), Ptr{Cchar}, (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), Cuint, (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 + +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), Ptr{Cchar}, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrGetDesc(conflicthdlr) + ccall((:SCIPconflicthdlrGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrGetPriority(conflicthdlr) + ccall((:SCIPconflicthdlrGetPriority, libscip), Cint, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) +end + +function SCIPconflicthdlrIsInitialized(conflicthdlr) + ccall((:SCIPconflicthdlrIsInitialized, libscip), Cuint, (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 + +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 SCIPconsCompCheck(elem1, elem2) + ccall((:SCIPconsCompCheck, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPconshdlrGetName(conshdlr) + ccall((:SCIPconshdlrGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrGetDesc(conshdlr) + ccall((:SCIPconshdlrGetDesc, libscip), Ptr{Cchar}, (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 SCIPconshdlrIsExact(conshdlr) + ccall((:SCIPconshdlrIsExact, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrMarkExact(conshdlr) + ccall((:SCIPconshdlrMarkExact, libscip), Cvoid, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrSetSepa(conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) + ccall((:SCIPconshdlrSetSepa, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Cuint), conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) +end + +function SCIPconshdlrSetProp(conshdlr, consprop, propfreq, delayprop, timingmask) + ccall((:SCIPconshdlrSetProp, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, Cuint, 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 SCIPconshdlrGetUpdateConss(conshdlr) + ccall((:SCIPconshdlrGetUpdateConss, 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 SCIPconshdlrGetNUpdateConss(conshdlr) + ccall((:SCIPconshdlrGetNUpdateConss, 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), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrSetNeedsCons(conshdlr, needscons) + ccall((:SCIPconshdlrSetNeedsCons, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Cuint), conshdlr, needscons) +end + +function SCIPconshdlrDoesPresolve(conshdlr) + ccall((:SCIPconshdlrDoesPresolve, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrIsSeparationDelayed(conshdlr) + ccall((:SCIPconshdlrIsSeparationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrIsPropagationDelayed(conshdlr) + ccall((:SCIPconshdlrIsPropagationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrWasLPSeparationDelayed(conshdlr) + ccall((:SCIPconshdlrWasLPSeparationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrWasSolSeparationDelayed(conshdlr) + ccall((:SCIPconshdlrWasSolSeparationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrWasPropagationDelayed(conshdlr) + ccall((:SCIPconshdlrWasPropagationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrIsInitialized(conshdlr) + ccall((:SCIPconshdlrIsInitialized, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrIsClonable(conshdlr) + ccall((:SCIPconshdlrIsClonable, libscip), Cuint, (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 SCIPconshdlrSupportsPermsymDetection(conshdlr) + ccall((:SCIPconshdlrSupportsPermsymDetection, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconshdlrSupportsSignedPermsymDetection(conshdlr) + ccall((:SCIPconshdlrSupportsSignedPermsymDetection, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) +end + +function SCIPconsGetName(cons) + ccall((:SCIPconsGetName, libscip), Ptr{Cchar}, (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), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsUpdatedeactivate(cons) + ccall((:SCIPconsIsUpdatedeactivate, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsEnabled(cons) + ccall((:SCIPconsIsEnabled, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsSeparationEnabled(cons) + ccall((:SCIPconsIsSeparationEnabled, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsPropagationEnabled(cons) + ccall((:SCIPconsIsPropagationEnabled, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsDeleted(cons) + ccall((:SCIPconsIsDeleted, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsObsolete(cons) + ccall((:SCIPconsIsObsolete, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsConflict(cons) + ccall((:SCIPconsIsConflict, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsGetAge(cons) + ccall((:SCIPconsGetAge, libscip), Cdouble, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsInitial(cons) + ccall((:SCIPconsIsInitial, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsSeparated(cons) + ccall((:SCIPconsIsSeparated, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsEnforced(cons) + ccall((:SCIPconsIsEnforced, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsChecked(cons) + ccall((:SCIPconsIsChecked, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsMarkedPropagate(cons) + ccall((:SCIPconsIsMarkedPropagate, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsPropagated(cons) + ccall((:SCIPconsIsPropagated, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsGlobal(cons) + ccall((:SCIPconsIsGlobal, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLocal(cons) + ccall((:SCIPconsIsLocal, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsModifiable(cons) + ccall((:SCIPconsIsModifiable, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsDynamic(cons) + ccall((:SCIPconsIsDynamic, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsRemovable(cons) + ccall((:SCIPconsIsRemovable, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsStickingAtNode(cons) + ccall((:SCIPconsIsStickingAtNode, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsInProb(cons) + ccall((:SCIPconsIsInProb, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsOriginal(cons) + ccall((:SCIPconsIsOriginal, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsTransformed(cons) + ccall((:SCIPconsIsTransformed, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLockedPos(cons) + ccall((:SCIPconsIsLockedPos, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLockedNeg(cons) + ccall((:SCIPconsIsLockedNeg, libscip), Cuint, (Ptr{SCIP_CONS},), cons) +end + +function SCIPconsIsLocked(cons) + ccall((:SCIPconsIsLocked, libscip), Cuint, (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), Cuint, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) +end + +function SCIPconsIsLockedTypeNeg(cons, locktype) + ccall((:SCIPconsIsLockedTypeNeg, libscip), Cuint, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) +end + +function SCIPconsIsLockedType(cons, locktype) + ccall((:SCIPconsIsLockedType, libscip), Cuint, (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), Cuint, (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{Libc.FILE}, Ptr{SCIP_LINCONSSTATS}), scip, file, linconsstats) +end + +function SCIPcutGetRow(cut) + ccall((:SCIPcutGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_CUT},), cut) +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), Clonglong, (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 SCIPcutpoolGetNRootCalls(cutpool) + ccall((:SCIPcutpoolGetNRootCalls, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) +end + +function SCIPcutpoolGetNCutsFound(cutpool) + ccall((:SCIPcutpoolGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) +end + +function SCIPcutpoolGetNCutsAdded(cutpool) + ccall((:SCIPcutpoolGetNCutsAdded, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) +end + +function SCIPcutselGetName(cutsel) + ccall((:SCIPcutselGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetData(cutsel) + ccall((:SCIPcutselGetData, libscip), Ptr{SCIP_CUTSELDATA}, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetDesc(cutsel) + ccall((:SCIPcutselGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetPriority(cutsel) + ccall((:SCIPcutselGetPriority, libscip), Cint, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselSetData(cutsel, cutseldata) + ccall((:SCIPcutselSetData, libscip), Cvoid, (Ptr{SCIP_CUTSEL}, Ptr{SCIP_CUTSELDATA}), cutsel, cutseldata) +end + +function SCIPcutselIsInitialized(cutsel) + ccall((:SCIPcutselIsInitialized, libscip), Cuint, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetSetupTime(cutsel) + ccall((:SCIPcutselGetSetupTime, libscip), Cdouble, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetTime(cutsel) + ccall((:SCIPcutselGetTime, libscip), Cdouble, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetNCalls(cutsel) + ccall((:SCIPcutselGetNCalls, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetNRootCalls(cutsel) + ccall((:SCIPcutselGetNRootCalls, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetNRootCuts(cutsel) + ccall((:SCIPcutselGetNRootCuts, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetNRootForcedCuts(cutsel) + ccall((:SCIPcutselGetNRootForcedCuts, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetNRootCutsFiltered(cutsel) + ccall((:SCIPcutselGetNRootCutsFiltered, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetNLocalCuts(cutsel) + ccall((:SCIPcutselGetNLocalCuts, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetNLocalForcedCuts(cutsel) + ccall((:SCIPcutselGetNLocalForcedCuts, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselGetNLocalCutsFiltered(cutsel) + ccall((:SCIPcutselGetNLocalCutsFiltered, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) +end + +function SCIPcutselComp(elem1, elem2) + ccall((:SCIPcutselComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPdatatreeGetBool(datatree, name, value) + ccall((:SCIPdatatreeGetBool, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cuint}), datatree, name, value) +end + +function SCIPdatatreeGetLong(datatree, name, value) + ccall((:SCIPdatatreeGetLong, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Clonglong}), datatree, name, value) +end + +function SCIPdatatreeGetReal(datatree, name, value) + ccall((:SCIPdatatreeGetReal, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cdouble}), datatree, name, value) +end + +function SCIPdatatreeGetString(datatree, name, value) + ccall((:SCIPdatatreeGetString, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), datatree, name, value) +end + +function SCIPdatatreeGetBoolArray(datatree, name, values, nvalues) + ccall((:SCIPdatatreeGetBoolArray, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cuint}}, Ptr{Cint}), datatree, name, values, nvalues) +end + +function SCIPdatatreeGetLongArray(datatree, name, values, nvalues) + ccall((:SCIPdatatreeGetLongArray, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Clonglong}}, Ptr{Cint}), datatree, name, values, nvalues) +end + +function SCIPdatatreeGetRealArray(datatree, name, values, nvalues) + ccall((:SCIPdatatreeGetRealArray, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cdouble}}, Ptr{Cint}), datatree, name, values, nvalues) +end + +function SCIPdatatreeGetStringArray(datatree, name, values, nvalues) + ccall((:SCIPdatatreeGetStringArray, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Ptr{Cchar}}}, Ptr{Cint}), datatree, name, values, nvalues) +end + +function SCIPdatatreeGetTree(datatree, name, value) + ccall((:SCIPdatatreeGetTree, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{SCIP_DATATREE}}), datatree, name, value) +end + +function SCIPdecompCreate(decomp, blkmem, nblocks, original, benderslabels) + ccall((:SCIPdecompCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_DECOMP}}, Ptr{BMS_BLKMEM}, Cint, Cuint, Cuint), decomp, blkmem, nblocks, original, benderslabels) +end + +function SCIPdecompFree(decomp, blkmem) + ccall((:SCIPdecompFree, libscip), Cvoid, (Ptr{Ptr{SCIP_DECOMP}}, Ptr{BMS_BLKMEM}), decomp, blkmem) +end + +function SCIPdecompIsOriginal(decomp) + ccall((:SCIPdecompIsOriginal, libscip), Cuint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompSetUseBendersLabels(decomp, benderslabels) + ccall((:SCIPdecompSetUseBendersLabels, libscip), Cvoid, (Ptr{SCIP_DECOMP}, Cuint), decomp, benderslabels) +end + +function SCIPdecompUseBendersLabels(decomp) + ccall((:SCIPdecompUseBendersLabels, libscip), Cuint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetNBlocks(decomp) + ccall((:SCIPdecompGetNBlocks, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetAreaScore(decomp) + ccall((:SCIPdecompGetAreaScore, libscip), Cdouble, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetModularity(decomp) + ccall((:SCIPdecompGetModularity, libscip), Cdouble, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetVarsSize(decomp, varssize, nlabels) + ccall((:SCIPdecompGetVarsSize, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Ptr{Cint}, Cint), decomp, varssize, nlabels) +end + +function SCIPdecompGetConssSize(decomp, consssize, nlabels) + ccall((:SCIPdecompGetConssSize, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Ptr{Cint}, Cint), decomp, consssize, nlabels) +end + +function SCIPdecompGetNBorderVars(decomp) + ccall((:SCIPdecompGetNBorderVars, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetNBorderConss(decomp) + ccall((:SCIPdecompGetNBorderConss, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetNBlockGraphEdges(decomp) + ccall((:SCIPdecompGetNBlockGraphEdges, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetNBlockGraphComponents(decomp) + ccall((:SCIPdecompGetNBlockGraphComponents, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetNBlockGraphArticulations(decomp) + ccall((:SCIPdecompGetNBlockGraphArticulations, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetBlockGraphMaxDegree(decomp) + ccall((:SCIPdecompGetBlockGraphMaxDegree, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompGetBlockGraphMinDegree(decomp) + ccall((:SCIPdecompGetBlockGraphMinDegree, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) +end + +function SCIPdecompSetVarsLabels(decomp, vars, labels, nvars) + ccall((:SCIPdecompSetVarsLabels, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), decomp, vars, labels, nvars) +end + +function SCIPdecompGetVarsLabels(decomp, vars, labels, nvars) + ccall((:SCIPdecompGetVarsLabels, libscip), Cvoid, (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), decomp, vars, labels, nvars) +end + +function SCIPdecompSetConsLabels(decomp, conss, labels, nconss) + ccall((:SCIPdecompSetConsLabels, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), decomp, conss, labels, nconss) +end + +function SCIPdecompGetConsLabels(decomp, conss, labels, nconss) + ccall((:SCIPdecompGetConsLabels, libscip), Cvoid, (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), decomp, conss, labels, nconss) +end + +function SCIPdecompClear(decomp, clearvarlabels, clearconslabels) + ccall((:SCIPdecompClear, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Cuint, Cuint), decomp, clearvarlabels, clearconslabels) +end + +function SCIPdecompPrintStats(decomp, strbuf) + ccall((:SCIPdecompPrintStats, libscip), Ptr{Cchar}, (Ptr{SCIP_DECOMP}, Ptr{Cchar}), decomp, strbuf) +end + +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), Cuint, (Ptr{SCIP_DIALOGHDLR},), dialoghdlr) +end + +function SCIPdialoghdlrGetLine(dialoghdlr, dialog, prompt, inputline, endoffile) + ccall((:SCIPdialoghdlrGetLine, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), dialoghdlr, dialog, prompt, inputline, endoffile) +end + +function SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, inputword, endoffile) + ccall((:SCIPdialoghdlrGetWord, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), dialoghdlr, dialog, prompt, inputword, endoffile) +end + +function SCIPdialoghdlrAddInputLine(dialoghdlr, inputline) + ccall((:SCIPdialoghdlrAddInputLine, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{Cchar}), dialoghdlr, inputline) +end + +function SCIPdialoghdlrAddHistory(dialoghdlr, dialog, command, escapecommand) + ccall((:SCIPdialoghdlrAddHistory, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Ptr{Cchar}, Cuint), dialoghdlr, dialog, command, escapecommand) +end + +function SCIPdialogHasEntry(dialog, entryname) + ccall((:SCIPdialogHasEntry, libscip), Cuint, (Ptr{SCIP_DIALOG}, Ptr{Cchar}), dialog, entryname) +end + +function SCIPdialogFindEntry(dialog, entryname, subdialog) + ccall((:SCIPdialogFindEntry, libscip), Cint, (Ptr{SCIP_DIALOG}, Ptr{Cchar}, 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}, Ptr{Cchar}), dialog, scip, entryname) +end + +function SCIPdialogGetPath(dialog, sepchar, path) + ccall((:SCIPdialogGetPath, libscip), Cvoid, (Ptr{SCIP_DIALOG}, Cchar, Ptr{Cchar}), dialog, sepchar, path) +end + +function SCIPdialogGetName(dialog) + ccall((:SCIPdialogGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogGetDesc(dialog) + ccall((:SCIPdialogGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogIsSubmenu(dialog) + ccall((:SCIPdialogIsSubmenu, libscip), Cuint, (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 SCIPdialogIsHidden(dialog) + ccall((:SCIPdialogIsHidden, libscip), Cuint, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogSetHidden(dialog) + ccall((:SCIPdialogSetHidden, libscip), Cvoid, (Ptr{SCIP_DIALOG},), dialog) +end + +function SCIPdialogWriteHistory(filename) + ccall((:SCIPdialogWriteHistory, libscip), SCIP_RETCODE, (Ptr{Cchar},), filename) +end + +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), Ptr{Cchar}, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispGetDesc(disp) + ccall((:SCIPdispGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispGetHeader(disp) + ccall((:SCIPdispGetHeader, libscip), Ptr{Cchar}, (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), Cuint, (Ptr{SCIP_DISP},), disp) +end + +function SCIPdispLongint(messagehdlr, file, val, width) + ccall((:SCIPdispLongint, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Clonglong, Cint), messagehdlr, file, val, width) +end + +function SCIPdispInt(messagehdlr, file, val, width) + ccall((:SCIPdispInt, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Cint, Cint), messagehdlr, file, val, width) +end + +function SCIPdispTime(messagehdlr, file, val, width) + ccall((:SCIPdispTime, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Cdouble, Cint), messagehdlr, file, val, width) +end + +function SCIPeventhdlrGetName(eventhdlr) + ccall((:SCIPeventhdlrGetName, libscip), Ptr{Cchar}, (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), Cuint, (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 SCIPeventGetOldboundExact(event) + ccall((:SCIPeventGetOldboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetNewbound(event) + ccall((:SCIPeventGetNewbound, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetOldtype(event) + ccall((:SCIPeventGetOldtype, libscip), SCIP_VARTYPE, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetNewtype(event) + ccall((:SCIPeventGetNewtype, libscip), SCIP_VARTYPE, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetOldImpltype(event) + ccall((:SCIPeventGetOldImpltype, libscip), SCIP_IMPLINTTYPE, (Ptr{SCIP_EVENT},), event) +end + +function SCIPeventGetNewImpltype(event) + ccall((:SCIPeventGetNewImpltype, libscip), SCIP_IMPLINTTYPE, (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 + +function SCIPexprhdlrSetCopyFreeHdlr(exprhdlr, copyhdlr, freehdlr) + ccall((:SCIPexprhdlrSetCopyFreeHdlr, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), exprhdlr, copyhdlr, freehdlr) +end + +function SCIPexprhdlrSetCopyFreeData(exprhdlr, copydata, freedata) + ccall((:SCIPexprhdlrSetCopyFreeData, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), exprhdlr, copydata, freedata) +end + +function SCIPexprhdlrSetPrint(exprhdlr, print) + ccall((:SCIPexprhdlrSetPrint, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, print) +end + +function SCIPexprhdlrSetParse(exprhdlr, parse) + ccall((:SCIPexprhdlrSetParse, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, parse) +end + +function SCIPexprhdlrSetCurvature(exprhdlr, curvature) + ccall((:SCIPexprhdlrSetCurvature, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, curvature) +end + +function SCIPexprhdlrSetMonotonicity(exprhdlr, monotonicity) + ccall((:SCIPexprhdlrSetMonotonicity, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, monotonicity) +end + +function SCIPexprhdlrSetIntegrality(exprhdlr, integrality) + ccall((:SCIPexprhdlrSetIntegrality, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, integrality) +end + +function SCIPexprhdlrSetHash(exprhdlr, hash) + ccall((:SCIPexprhdlrSetHash, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, hash) +end + +function SCIPexprhdlrSetCompare(exprhdlr, compare) + ccall((:SCIPexprhdlrSetCompare, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, compare) +end + +function SCIPexprhdlrSetDiff(exprhdlr, bwdiff, fwdiff, bwfwdiff) + ccall((:SCIPexprhdlrSetDiff, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), exprhdlr, bwdiff, fwdiff, bwfwdiff) +end + +function SCIPexprhdlrSetIntEval(exprhdlr, inteval) + ccall((:SCIPexprhdlrSetIntEval, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, inteval) +end + +function SCIPexprhdlrSetSimplify(exprhdlr, simplify) + ccall((:SCIPexprhdlrSetSimplify, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, simplify) +end + +function SCIPexprhdlrSetReverseProp(exprhdlr, reverseprop) + ccall((:SCIPexprhdlrSetReverseProp, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, reverseprop) +end + +function SCIPexprhdlrSetEstimate(exprhdlr, initestimates, estimate) + ccall((:SCIPexprhdlrSetEstimate, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), exprhdlr, initestimates, estimate) +end + +function SCIPexprhdlrSetGetSymdata(exprhdlr, getsymdata) + ccall((:SCIPexprhdlrSetGetSymdata, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, getsymdata) +end + +function SCIPexprhdlrGetName(exprhdlr) + ccall((:SCIPexprhdlrGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetDescription(exprhdlr) + ccall((:SCIPexprhdlrGetDescription, libscip), Ptr{Cchar}, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetPrecedence(exprhdlr) + ccall((:SCIPexprhdlrGetPrecedence, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetData(exprhdlr) + ccall((:SCIPexprhdlrGetData, libscip), Ptr{SCIP_EXPRHDLRDATA}, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasPrint(exprhdlr) + ccall((:SCIPexprhdlrHasPrint, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasBwdiff(exprhdlr) + ccall((:SCIPexprhdlrHasBwdiff, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasFwdiff(exprhdlr) + ccall((:SCIPexprhdlrHasFwdiff, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasIntEval(exprhdlr) + ccall((:SCIPexprhdlrHasIntEval, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasEstimate(exprhdlr) + ccall((:SCIPexprhdlrHasEstimate, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasInitEstimates(exprhdlr) + ccall((:SCIPexprhdlrHasInitEstimates, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasSimplify(exprhdlr) + ccall((:SCIPexprhdlrHasSimplify, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasCurvature(exprhdlr) + ccall((:SCIPexprhdlrHasCurvature, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasMonotonicity(exprhdlr) + ccall((:SCIPexprhdlrHasMonotonicity, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasReverseProp(exprhdlr) + ccall((:SCIPexprhdlrHasReverseProp, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrHasGetSymData(exprhdlr) + ccall((:SCIPexprhdlrHasGetSymData, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end function SCIPexprhdlrComp(elem1, elem2) - ccall( - (:SCIPexprhdlrComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) + ccall((:SCIPexprhdlrComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPexprhdlrGetNCreated(exprhdlr) + ccall((:SCIPexprhdlrGetNCreated, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetNIntevalCalls(exprhdlr) + ccall((:SCIPexprhdlrGetNIntevalCalls, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetIntevalTime(exprhdlr) + ccall((:SCIPexprhdlrGetIntevalTime, libscip), Cdouble, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetNReversepropCalls(exprhdlr) + ccall((:SCIPexprhdlrGetNReversepropCalls, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetReversepropTime(exprhdlr) + ccall((:SCIPexprhdlrGetReversepropTime, libscip), Cdouble, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetNCutoffs(exprhdlr) + ccall((:SCIPexprhdlrGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetNDomainReductions(exprhdlr) + ccall((:SCIPexprhdlrGetNDomainReductions, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrIncrementNDomainReductions(exprhdlr, nreductions) + ccall((:SCIPexprhdlrIncrementNDomainReductions, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Cint), exprhdlr, nreductions) +end + +function SCIPexprhdlrGetNEstimateCalls(exprhdlr) + ccall((:SCIPexprhdlrGetNEstimateCalls, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetEstimateTime(exprhdlr) + ccall((:SCIPexprhdlrGetEstimateTime, libscip), Cdouble, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetNBranchings(exprhdlr) + ccall((:SCIPexprhdlrGetNBranchings, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrIncrementNBranchings(exprhdlr) + ccall((:SCIPexprhdlrIncrementNBranchings, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetNSimplifyCalls(exprhdlr) + ccall((:SCIPexprhdlrGetNSimplifyCalls, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetSimplifyTime(exprhdlr) + ccall((:SCIPexprhdlrGetSimplifyTime, libscip), Cdouble, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprhdlrGetNSimplifications(exprhdlr) + ccall((:SCIPexprhdlrGetNSimplifications, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) +end + +function SCIPexprGetNUses(expr) + ccall((:SCIPexprGetNUses, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetNChildren(expr) + ccall((:SCIPexprGetNChildren, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetChildren(expr) + ccall((:SCIPexprGetChildren, libscip), Ptr{Ptr{SCIP_EXPR}}, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetHdlr(expr) + ccall((:SCIPexprGetHdlr, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetData(expr) + ccall((:SCIPexprGetData, libscip), Ptr{SCIP_EXPRDATA}, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprSetData(expr, exprdata) + ccall((:SCIPexprSetData, libscip), Cvoid, (Ptr{SCIP_EXPR}, Ptr{SCIP_EXPRDATA}), expr, exprdata) +end + +function SCIPexprGetOwnerData(expr) + ccall((:SCIPexprGetOwnerData, libscip), Ptr{SCIP_EXPR_OWNERDATA}, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetEvalValue(expr) + ccall((:SCIPexprGetEvalValue, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetEvalTag(expr) + ccall((:SCIPexprGetEvalTag, libscip), Clonglong, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetDerivative(expr) + ccall((:SCIPexprGetDerivative, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetDot(expr) + ccall((:SCIPexprGetDot, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetBardot(expr) + ccall((:SCIPexprGetBardot, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetDiffTag(expr) + ccall((:SCIPexprGetDiffTag, libscip), Clonglong, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetActivity(expr) + ccall((:SCIPexprGetActivity, libscip), SCIP_INTERVAL, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprGetActivityTag(expr) + ccall((:SCIPexprGetActivityTag, libscip), Clonglong, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprSetActivity(expr, activity, activitytag) + ccall((:SCIPexprSetActivity, libscip), Cvoid, (Ptr{SCIP_EXPR}, SCIP_INTERVAL, Clonglong), expr, activity, activitytag) +end + +function SCIPexprGetCurvature(expr) + ccall((:SCIPexprGetCurvature, libscip), SCIP_EXPRCURV, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprSetCurvature(expr, curvature) + ccall((:SCIPexprSetCurvature, libscip), Cvoid, (Ptr{SCIP_EXPR}, SCIP_EXPRCURV), expr, curvature) +end + +function SCIPexprGetIntegrality(expr) + ccall((:SCIPexprGetIntegrality, libscip), SCIP_IMPLINTTYPE, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprIsIntegral(expr) + ccall((:SCIPexprIsIntegral, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexprSetIntegrality(expr, integrality) + ccall((:SCIPexprSetIntegrality, libscip), Cvoid, (Ptr{SCIP_EXPR}, SCIP_IMPLINTTYPE), expr, integrality) +end + +function SCIPexprGetQuadraticData(expr, constant, nlinexprs, linexprs, lincoefs, nquadexprs, nbilinexprs, eigenvalues, eigenvectors) + ccall((:SCIPexprGetQuadraticData, libscip), Cvoid, (Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Ptr{SCIP_EXPR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}), expr, constant, nlinexprs, linexprs, lincoefs, nquadexprs, nbilinexprs, eigenvalues, eigenvectors) +end + +function SCIPexprGetQuadraticQuadTerm(quadexpr, termidx, expr, lincoef, sqrcoef, nadjbilin, adjbilin, sqrexpr) + ccall((:SCIPexprGetQuadraticQuadTerm, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cint}}, Ptr{Ptr{SCIP_EXPR}}), quadexpr, termidx, expr, lincoef, sqrcoef, nadjbilin, adjbilin, sqrexpr) +end + +function SCIPexprGetQuadraticBilinTerm(expr, termidx, expr1, expr2, coef, pos2, prodexpr) + ccall((:SCIPexprGetQuadraticBilinTerm, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint, Ptr{Ptr{SCIP_EXPR}}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{SCIP_EXPR}}), expr, termidx, expr1, expr2, coef, pos2, prodexpr) +end + +function SCIPexprAreQuadraticExprsVariables(expr) + ccall((:SCIPexprAreQuadraticExprsVariables, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetVarExprVar(expr) + ccall((:SCIPgetVarExprVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetValueExprValue(expr) + ccall((:SCIPgetValueExprValue, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetCoefsExprSum(expr) + ccall((:SCIPgetCoefsExprSum, libscip), Ptr{Cdouble}, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetConstantExprSum(expr) + ccall((:SCIPgetConstantExprSum, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetCoefExprProduct(expr) + ccall((:SCIPgetCoefExprProduct, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPgetExponentExprPow(expr) + ccall((:SCIPgetExponentExprPow, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +end + +function SCIPexpriterIsInit(iterator) + ccall((:SCIPexpriterIsInit, libscip), Cuint, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterInit(iterator, expr, type, allowrevisit) + ccall((:SCIPexpriterInit, libscip), SCIP_RETCODE, (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_TYPE, Cuint), iterator, expr, type, allowrevisit) +end + +function SCIPexpriterRestartDFS(iterator, expr) + ccall((:SCIPexpriterRestartDFS, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}), iterator, expr) +end + +function SCIPexpriterSetStagesDFS(iterator, stopstages) + ccall((:SCIPexpriterSetStagesDFS, libscip), Cvoid, (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_STAGE), iterator, stopstages) +end + +function SCIPexpriterGetCurrent(iterator) + ccall((:SCIPexpriterGetCurrent, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterGetStageDFS(iterator) + ccall((:SCIPexpriterGetStageDFS, libscip), SCIP_EXPRITER_STAGE, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterGetChildIdxDFS(iterator) + ccall((:SCIPexpriterGetChildIdxDFS, libscip), Cint, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterGetChildExprDFS(iterator) + ccall((:SCIPexpriterGetChildExprDFS, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterGetParentDFS(iterator) + ccall((:SCIPexpriterGetParentDFS, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterGetCurrentUserData(iterator) + ccall((:SCIPexpriterGetCurrentUserData, libscip), SCIP_EXPRITER_USERDATA, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterGetChildUserDataDFS(iterator) + ccall((:SCIPexpriterGetChildUserDataDFS, libscip), SCIP_EXPRITER_USERDATA, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterGetExprUserData(iterator, expr) + ccall((:SCIPexpriterGetExprUserData, libscip), SCIP_EXPRITER_USERDATA, (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}), iterator, expr) +end + +function SCIPexpriterSetCurrentUserData(iterator, userdata) + ccall((:SCIPexpriterSetCurrentUserData, libscip), Cvoid, (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_USERDATA), iterator, userdata) +end + +function SCIPexpriterSetExprUserData(iterator, expr, userdata) + ccall((:SCIPexpriterSetExprUserData, libscip), Cvoid, (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_USERDATA), iterator, expr, userdata) +end + +function SCIPexpriterSetChildUserData(iterator, userdata) + ccall((:SCIPexpriterSetChildUserData, libscip), Cvoid, (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_USERDATA), iterator, userdata) +end + +function SCIPexpriterGetNext(iterator) + ccall((:SCIPexpriterGetNext, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterSkipDFS(iterator) + ccall((:SCIPexpriterSkipDFS, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexpriterIsEnd(iterator) + ccall((:SCIPexpriterIsEnd, libscip), Cuint, (Ptr{SCIP_EXPRITER},), iterator) +end + +function SCIPexprcurvAdd(curv1, curv2) + ccall((:SCIPexprcurvAdd, libscip), SCIP_EXPRCURV, (SCIP_EXPRCURV, SCIP_EXPRCURV), curv1, curv2) +end + +function SCIPexprcurvNegate(curvature) + ccall((:SCIPexprcurvNegate, libscip), SCIP_EXPRCURV, (SCIP_EXPRCURV,), curvature) +end + +function SCIPexprcurvMultiply(factor, curvature) + ccall((:SCIPexprcurvMultiply, libscip), SCIP_EXPRCURV, (Cdouble, SCIP_EXPRCURV), factor, curvature) +end + +function SCIPexprcurvPower(basebounds, basecurv, exponent) + ccall((:SCIPexprcurvPower, libscip), SCIP_EXPRCURV, (SCIP_INTERVAL, SCIP_EXPRCURV, Cdouble), basebounds, basecurv, exponent) +end + +function SCIPexprcurvPowerInv(basebounds, exponent, powercurv) + ccall((:SCIPexprcurvPowerInv, libscip), SCIP_EXPRCURV, (SCIP_INTERVAL, Cdouble, SCIP_EXPRCURV), basebounds, exponent, powercurv) +end + +function SCIPexprcurvMonomial(nfactors, exponents, factoridxs, factorcurv, factorbounds) + ccall((:SCIPexprcurvMonomial, libscip), SCIP_EXPRCURV, (Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{SCIP_EXPRCURV}, Ptr{SCIP_INTERVAL}), nfactors, exponents, factoridxs, factorcurv, factorbounds) +end + +function SCIPexprcurvMonomialInv(monomialcurv, nfactors, exponents, factorbounds, factorcurv) + ccall((:SCIPexprcurvMonomialInv, libscip), Cuint, (SCIP_EXPRCURV, Cint, Ptr{Cdouble}, Ptr{SCIP_INTERVAL}, Ptr{SCIP_EXPRCURV}), monomialcurv, nfactors, exponents, factorbounds, factorcurv) +end + +function SCIPexprcurvGetName(curv) + ccall((:SCIPexprcurvGetName, libscip), Ptr{Cchar}, (SCIP_EXPRCURV,), curv) +end + +const SCIP_File = Cvoid + +const SCIP_FILE = SCIP_File + +function SCIPfopen(path, mode) + ccall((:SCIPfopen, libscip), Ptr{SCIP_FILE}, (Ptr{Cchar}, Ptr{Cchar}), path, mode) +end + +function SCIPfdopen(fildes, mode) + ccall((:SCIPfdopen, libscip), Ptr{SCIP_FILE}, (Cint, Ptr{Cchar}), 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, (Ptr{Cchar}, 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), Ptr{Cchar}, (Ptr{Cchar}, 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 + +function SCIPheurComp(elem1, elem2) + ccall((:SCIPheurComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPheurCompPriority(elem1, elem2) + ccall((:SCIPheurCompPriority, 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 SCIPheurMarkExact(heur) + ccall((:SCIPheurMarkExact, libscip), Cvoid, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetName(heur) + ccall((:SCIPheurGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetDesc(heur) + ccall((:SCIPheurGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_HEUR},), heur) +end + +function SCIPheurGetDispchar(heur) + ccall((:SCIPheurGetDispchar, libscip), Cchar, (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), Cuint, (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), Cuint, (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), Ptr{Cchar}, (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, divecontext) + ccall((:SCIPdivesetGetSolSuccess, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetNCalls(diveset, divecontext) + ccall((:SCIPdivesetGetNCalls, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetNSolutionCalls(diveset, divecontext) + ccall((:SCIPdivesetGetNSolutionCalls, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetMinDepth(diveset, divecontext) + ccall((:SCIPdivesetGetMinDepth, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetMaxDepth(diveset, divecontext) + ccall((:SCIPdivesetGetMaxDepth, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetAvgDepth(diveset, divecontext) + ccall((:SCIPdivesetGetAvgDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetMinSolutionDepth(diveset, divecontext) + ccall((:SCIPdivesetGetMinSolutionDepth, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetMaxSolutionDepth(diveset, divecontext) + ccall((:SCIPdivesetGetMaxSolutionDepth, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetAvgSolutionDepth(diveset, divecontext) + ccall((:SCIPdivesetGetAvgSolutionDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetNLPIterations(diveset, divecontext) + ccall((:SCIPdivesetGetNLPIterations, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetNProbingNodes(diveset, divecontext) + ccall((:SCIPdivesetGetNProbingNodes, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetNBacktracks(diveset, divecontext) + ccall((:SCIPdivesetGetNBacktracks, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetNConflicts(diveset, divecontext) + ccall((:SCIPdivesetGetNConflicts, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +end + +function SCIPdivesetGetNSols(diveset, divecontext) + ccall((:SCIPdivesetGetNSols, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) +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), Cuint, (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), Cuint, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetSupportsType(diveset, divetype) + ccall((:SCIPdivesetSupportsType, libscip), Cuint, (Ptr{SCIP_DIVESET}, SCIP_DIVETYPE), diveset, divetype) +end + +function SCIPdivesetGetRandnumgen(diveset) + ccall((:SCIPdivesetGetRandnumgen, libscip), Ptr{SCIP_RANDNUMGEN}, (Ptr{SCIP_DIVESET},), diveset) +end + +function SCIPdivesetIsPublic(diveset) + ccall((:SCIPdivesetIsPublic, libscip), Cuint, (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}}, Cuint, 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 + +function SCIPhistoryGetVSIDS(history, dir) + ccall((:SCIPhistoryGetVSIDS, libscip), Cdouble, (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), history, dir) +end + +function SCIPhistoryGetAvgConflictlength(history, dir) + ccall((:SCIPhistoryGetAvgConflictlength, 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 SCIPhistoryGetInferenceSum(history, dir) + ccall((:SCIPhistoryGetInferenceSum, 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 + +function SCIPiisfinderGetName(iisfinder) + ccall((:SCIPiisfinderGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_IISFINDER},), iisfinder) +end + +function SCIPiisfinderGetData(iisfinder) + ccall((:SCIPiisfinderGetData, libscip), Ptr{SCIP_IISFINDERDATA}, (Ptr{SCIP_IISFINDER},), iisfinder) +end + +function SCIPiisfinderGetDesc(iisfinder) + ccall((:SCIPiisfinderGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_IISFINDER},), iisfinder) +end + +function SCIPiisfinderGetPriority(iisfinder) + ccall((:SCIPiisfinderGetPriority, libscip), Cint, (Ptr{SCIP_IISFINDER},), iisfinder) +end + +function SCIPiisfinderSetData(iisfinder, iisfinderdata) + ccall((:SCIPiisfinderSetData, libscip), Cvoid, (Ptr{SCIP_IISFINDER}, Ptr{SCIP_IISFINDERDATA}), iisfinder, iisfinderdata) +end + +function SCIPiisfinderGetTime(iisfinder) + ccall((:SCIPiisfinderGetTime, libscip), Cdouble, (Ptr{SCIP_IISFINDER},), iisfinder) +end + +function SCIPiisfinderInfoMessage(iis, printheaders) + ccall((:SCIPiisfinderInfoMessage, libscip), Cvoid, (Ptr{SCIP_IIS}, Cuint), iis, printheaders) +end + +function SCIPiisGetTime(iis) + ccall((:SCIPiisGetTime, libscip), Cdouble, (Ptr{SCIP_IIS},), iis) +end + +function SCIPiisIsSubscipInfeasible(iis) + ccall((:SCIPiisIsSubscipInfeasible, libscip), Cuint, (Ptr{SCIP_IIS},), iis) +end + +function SCIPiisIsSubscipIrreducible(iis) + ccall((:SCIPiisIsSubscipIrreducible, libscip), Cuint, (Ptr{SCIP_IIS},), iis) +end + +function SCIPiisGetNNodes(iis) + ccall((:SCIPiisGetNNodes, libscip), Clonglong, (Ptr{SCIP_IIS},), iis) +end + +function SCIPiisSetSubscipInfeasible(iis, infeasible) + ccall((:SCIPiisSetSubscipInfeasible, libscip), Cvoid, (Ptr{SCIP_IIS}, Cuint), iis, infeasible) +end + +function SCIPiisSetSubscipIrreducible(iis, irreducible) + ccall((:SCIPiisSetSubscipIrreducible, libscip), Cvoid, (Ptr{SCIP_IIS}, Cuint), iis, irreducible) +end + +function SCIPiisAddNNodes(iis, nnodes) + ccall((:SCIPiisAddNNodes, libscip), Cvoid, (Ptr{SCIP_IIS}, Clonglong), iis, nnodes) +end + +function SCIPiisGetRandnumgen(iis) + ccall((:SCIPiisGetRandnumgen, libscip), Ptr{SCIP_RANDNUMGEN}, (Ptr{SCIP_IIS},), iis) +end + +function SCIPiisGetSubscip(iis) + ccall((:SCIPiisGetSubscip, libscip), Ptr{SCIP}, (Ptr{SCIP_IIS},), iis) +end + +function SCIPiisfinderComp(elem1, elem2) + ccall((:SCIPiisfinderComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPcliqueSearchVar(clique, var, value) + ccall((:SCIPcliqueSearchVar, libscip), Cint, (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, Cuint), clique, var, value) +end + +function SCIPcliqueHasVar(clique, var, value) + ccall((:SCIPcliqueHasVar, libscip), Cuint, (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, Cuint), 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{Cuint}, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueGetId(clique) + ccall((:SCIPcliqueGetId, libscip), Cuint, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueGetIndex(clique) + ccall((:SCIPcliqueGetIndex, libscip), Cint, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueIsCleanedUp(clique) + ccall((:SCIPcliqueIsCleanedUp, libscip), Cuint, (Ptr{SCIP_CLIQUE},), clique) +end + +function SCIPcliqueIsEquation(clique) + ccall((:SCIPcliqueIsEquation, libscip), Cuint, (Ptr{SCIP_CLIQUE},), clique) +end + +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 + +@enum SCIP_BaseStat::UInt32 begin + SCIP_BASESTAT_LOWER = 0 + SCIP_BASESTAT_BASIC = 1 + SCIP_BASESTAT_UPPER = 2 + SCIP_BASESTAT_ZERO = 3 +end + +const SCIP_BASESTAT = SCIP_BaseStat + +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 SCIPcolGetVarProbindex(col) + ccall((:SCIPcolGetVarProbindex, libscip), Cint, (Ptr{SCIP_COL},), col) +end + +function SCIPcolIsIntegral(col) + ccall((:SCIPcolIsIntegral, libscip), Cuint, (Ptr{SCIP_COL},), col) +end + +function SCIPcolIsImpliedIntegral(col) + ccall((:SCIPcolIsImpliedIntegral, libscip), Cuint, (Ptr{SCIP_COL},), col) +end + +function SCIPcolIsRemovable(col) + ccall((:SCIPcolIsRemovable, libscip), Cuint, (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), Cuint, (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 SCIPcolGetAge(col) + ccall((:SCIPcolGetAge, 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}, Cchar), row1, row2, orthofunc) +end + +function SCIProwGetOrthogonality(row1, row2, orthofunc) + ccall((:SCIProwGetOrthogonality, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Cchar), 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), Ptr{Cchar}, (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), Cuint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsLocal(row) + ccall((:SCIProwIsLocal, libscip), Cuint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsModifiable(row) + ccall((:SCIProwIsModifiable, libscip), Cuint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwIsRemovable(row) + ccall((:SCIProwIsRemovable, libscip), Cuint, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetOrigintype(row) + ccall((:SCIProwGetOrigintype, libscip), SCIP_ROWORIGINTYPE, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetOriginConshdlr(row) + ccall((:SCIProwGetOriginConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP_ROW},), row) +end + +function SCIProwGetOriginCons(row) + ccall((:SCIProwGetOriginCons, libscip), Ptr{SCIP_CONS}, (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), Cuint, (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), Cuint, (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 + +function SCIProwGetRowExact(row) + ccall((:SCIProwGetRowExact, libscip), Ptr{SCIP_ROWEXACT}, (Ptr{SCIP_ROW},), row) +end + +function SCIProwExactComp(elem1, elem2) + ccall((:SCIProwExactComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +end + +function SCIPcolExactGetVar(col) + ccall((:SCIPcolExactGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_COLEXACT},), col) +end + +function SCIProwExactGetLhs(row) + ccall((:SCIProwExactGetLhs, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactGetRhs(row) + ccall((:SCIProwExactGetRhs, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactGetConstant(row) + ccall((:SCIProwExactGetConstant, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactGetNNonz(row) + ccall((:SCIProwExactGetNNonz, libscip), Cint, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactGetVals(row) + ccall((:SCIProwExactGetVals, libscip), Ptr{Ptr{SCIP_RATIONAL}}, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactIsInLP(row) + ccall((:SCIProwExactIsInLP, libscip), Cuint, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactSort(row) + ccall((:SCIProwExactSort, libscip), Cvoid, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactGetCols(row) + ccall((:SCIProwExactGetCols, libscip), Ptr{Ptr{SCIP_COLEXACT}}, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactLock(row) + ccall((:SCIProwExactLock, libscip), Cvoid, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactUnlock(row) + ccall((:SCIProwExactUnlock, libscip), Cvoid, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactGetRow(row) + ccall((:SCIProwExactGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactGetRowRhs(row) + ccall((:SCIProwExactGetRowRhs, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIProwExactHasFpRelax(row) + ccall((:SCIProwExactHasFpRelax, libscip), Cuint, (Ptr{SCIP_ROWEXACT},), row) +end + +function SCIPlpExactDiving(lpexact) + ccall((:SCIPlpExactDiving, libscip), Cuint, (Ptr{SCIP_LPEXACT},), lpexact) +end + +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), Ptr{Cchar}, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixGetRowValPtr(matrix, row) + ccall((:SCIPmatrixGetRowValPtr, libscip), Ptr{Cdouble}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowValPtrExact(matrix, row) + ccall((:SCIPmatrixGetRowValPtrExact, libscip), Ptr{Ptr{SCIP_RATIONAL}}, (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), Ptr{Cchar}, (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 SCIPmatrixGetRowLhsExact(matrix, row) + ccall((:SCIPmatrixGetRowLhsExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixGetRowRhsExact(matrix, row) + ccall((:SCIPmatrixGetRowRhsExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) +end + +function SCIPmatrixIsRowRhsInfinity(matrix, row) + ccall((:SCIPmatrixIsRowRhsInfinity, libscip), Cuint, (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), Cuint, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixDownlockConflict(matrix, col) + ccall((:SCIPmatrixDownlockConflict, libscip), Cuint, (Ptr{SCIP_MATRIX}, Cint), matrix, col) +end + +function SCIPmatrixCreate(scip, matrixptr, onlyifcomplete, initialized, complete, infeasible, naddconss, ndelconss, nchgcoefs, nchgbds, nfixedvars) + ccall((:SCIPmatrixCreate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_MATRIX}}, Cuint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, matrixptr, onlyifcomplete, initialized, complete, infeasible, naddconss, ndelconss, nchgcoefs, nchgbds, nfixedvars) +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 SCIPmatrixRemoveColumnBounds(scip, matrix, col) + ccall((:SCIPmatrixRemoveColumnBounds, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Cint), scip, matrix, col) +end + +function SCIPmatrixGetParallelCols(scip, matrix, scale, pclass, varineq) + ccall((:SCIPmatrixGetParallelCols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}), scip, matrix, scale, pclass, varineq) +end + +function SCIPmessagehdlrCreate(messagehdlr, bufferedoutput, filename, quiet, messagewarning, messagedialog, messageinfo, messagehdlrfree, messagehdlrdata) + ccall((:SCIPmessagehdlrCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_MESSAGEHDLR}}, Cuint, Ptr{Cchar}, Cuint, 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}, Ptr{Cchar}), messagehdlr, filename) +end + +function SCIPmessagehdlrSetQuiet(messagehdlr, quiet) + ccall((:SCIPmessagehdlrSetQuiet, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Cuint), messagehdlr, quiet) +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{Libc.FILE}, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) +end + +function SCIPmessagehdlrIsQuiet(messagehdlr) + ccall((:SCIPmessagehdlrIsQuiet, libscip), Cuint, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) +end + +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{Libc.FILE}, Cuint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}), file, id, label, nodetype, fillcolor, bordercolor) +end + +function SCIPgmlWriteNodeWeight(file, id, label, nodetype, fillcolor, bordercolor, weight) + ccall((:SCIPgmlWriteNodeWeight, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Cdouble), file, id, label, nodetype, fillcolor, bordercolor, weight) +end + +function SCIPgmlWriteEdge(file, source, target, label, color) + ccall((:SCIPgmlWriteEdge, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint, Cuint, Ptr{Cchar}, Ptr{Cchar}), file, source, target, label, color) +end + +function SCIPgmlWriteArc(file, source, target, label, color) + ccall((:SCIPgmlWriteArc, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint, Cuint, Ptr{Cchar}, Ptr{Cchar}), file, source, target, label, color) +end + +function SCIPgmlWriteOpening(file, directed) + ccall((:SCIPgmlWriteOpening, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint), file, directed) +end + +function SCIPgmlWriteClosing(file) + ccall((:SCIPgmlWriteClosing, libscip), Cvoid, (Ptr{Libc.FILE},), file) +end + +function SCIPdotWriteOpening(file) + ccall((:SCIPdotWriteOpening, libscip), Cvoid, (Ptr{Libc.FILE},), file) +end + +function SCIPdotWriteNode(file, node, label, nodetype, fillcolor, bordercolor) + ccall((:SCIPdotWriteNode, libscip), Cvoid, (Ptr{Libc.FILE}, Cint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}), file, node, label, nodetype, fillcolor, bordercolor) +end + +function SCIPdotWriteArc(file, source, target, color) + ccall((:SCIPdotWriteArc, libscip), Cvoid, (Ptr{Libc.FILE}, Cint, Cint, Ptr{Cchar}), file, source, target, color) +end + +function SCIPdotWriteClosing(file) + ccall((:SCIPdotWriteClosing, libscip), Cvoid, (Ptr{Libc.FILE},), file) +end + +function SCIPsparseSolCreate(sparsesol, vars, nvars, cleared) + ccall((:SCIPsparseSolCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SPARSESOL}}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint), 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), Cuint, (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 SCIPqueueInsertUInt(queue, elem) + ccall((:SCIPqueueInsertUInt, libscip), SCIP_RETCODE, (Ptr{SCIP_QUEUE}, Cuint), queue, elem) +end + +function SCIPqueueRemove(queue) + ccall((:SCIPqueueRemove, libscip), Ptr{Cvoid}, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueRemoveUInt(queue) + ccall((:SCIPqueueRemoveUInt, libscip), Cuint, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueFirst(queue) + ccall((:SCIPqueueFirst, libscip), Ptr{Cvoid}, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueFirstUInt(queue) + ccall((:SCIPqueueFirstUInt, libscip), Cuint, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueIsEmpty(queue) + ccall((:SCIPqueueIsEmpty, libscip), Cuint, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPqueueNElems(queue) + ccall((:SCIPqueueNElems, libscip), Cint, (Ptr{SCIP_QUEUE},), queue) +end + +function SCIPpqueueCreate(pqueue, initsize, sizefac, ptrcomp, elemchgpos) + ccall((:SCIPpqueueCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_PQUEUE}}, Cint, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), pqueue, initsize, sizefac, ptrcomp, elemchgpos) +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 SCIPpqueueDelPos(pqueue, pos) + ccall((:SCIPpqueueDelPos, libscip), Cvoid, (Ptr{SCIP_PQUEUE}, Cint), pqueue, pos) +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 SCIPpqueueFind(pqueue, elem) + ccall((:SCIPpqueueFind, libscip), Cint, (Ptr{SCIP_PQUEUE}, Ptr{Cvoid}), pqueue, elem) +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 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), Cuint, (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), Cuint, (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), Cuint, (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), Cuint, (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 SCIPhashmapInsertLong(hashmap, origin, image) + ccall((:SCIPhashmapInsertLong, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Clonglong), hashmap, origin, image) +end + +function SCIPhashmapInsertInt(hashmap, origin, image) + ccall((:SCIPhashmapInsertInt, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cint), 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 SCIPhashmapGetImageInt(hashmap, origin) + ccall((:SCIPhashmapGetImageInt, libscip), Cint, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), hashmap, origin) +end + +function SCIPhashmapGetImageLong(hashmap, origin) + ccall((:SCIPhashmapGetImageLong, libscip), Clonglong, (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 SCIPhashmapSetImageInt(hashmap, origin, image) + ccall((:SCIPhashmapSetImageInt, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cint), 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), Cuint, (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), Cuint, (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 SCIPhashmapEntryGetImageInt(entry) + ccall((:SCIPhashmapEntryGetImageInt, libscip), Cint, (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 SCIPhashmapEntrySetImageInt(entry, image) + ccall((:SCIPhashmapEntrySetImageInt, libscip), Cvoid, (Ptr{SCIP_HASHMAPENTRY}, Cint), 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), Cuint, (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), Cuint, (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 SCIPexprhdlrGetNCreated(exprhdlr) - ccall( - (:SCIPexprhdlrGetNCreated, libscip), - Cuint, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPhashsetGetSlots(hashset) + ccall((:SCIPhashsetGetSlots, libscip), Ptr{Ptr{Cvoid}}, (Ptr{SCIP_HASHSET},), hashset) end -function SCIPexprhdlrGetNIntevalCalls(exprhdlr) - ccall( - (:SCIPexprhdlrGetNIntevalCalls, libscip), - Clonglong, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPhashsetRemoveAll(hashset) + ccall((:SCIPhashsetRemoveAll, libscip), Cvoid, (Ptr{SCIP_HASHSET},), hashset) end -function SCIPexprhdlrGetIntevalTime(exprhdlr) - ccall( - (:SCIPexprhdlrGetIntevalTime, libscip), - Cdouble, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +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{Libc.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), Cuint, (Ptr{SCIP_PROFILE}, Cint, Ptr{Cint}), profile, timepoint, pos) +end + +function SCIPprofileInsertCore(profile, left, right, demand, pos, infeasible) + ccall((:SCIPprofileInsertCore, libscip), SCIP_RETCODE, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cuint}), profile, left, right, demand, pos, infeasible) +end + +function SCIPprofileDeleteCore(profile, left, right, demand) + ccall((:SCIPprofileDeleteCore, libscip), SCIP_RETCODE, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint), profile, left, right, demand) +end + +function SCIPprofileGetEarliestFeasibleStart(profile, est, lst, duration, demand, infeasible) + ccall((:SCIPprofileGetEarliestFeasibleStart, libscip), Cint, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Cint, Ptr{Cuint}), profile, est, lst, duration, demand, infeasible) +end + +function SCIPprofileGetLatestFeasibleStart(profile, est, lst, duration, demand, infeasible) + ccall((:SCIPprofileGetLatestFeasibleStart, libscip), Cint, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Cint, Ptr{Cuint}), profile, est, lst, duration, demand, 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 SCIPdigraphGetArticulationPoints(digraph, articulations, narticulations) + ccall((:SCIPdigraphGetArticulationPoints, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Ptr{Ptr{Cint}}, Ptr{Cint}), digraph, articulations, narticulations) +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{Libc.FILE}), digraph, messagehdlr, file) +end + +function SCIPdigraphPrintGml(digraph, file) + ccall((:SCIPdigraphPrintGml, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Ptr{Libc.FILE}), digraph, file) +end + +function SCIPdigraphPrintComponents(digraph, messagehdlr, file) + ccall((:SCIPdigraphPrintComponents, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.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), Cuint, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeIsLeaf(node) + ccall((:SCIPbtnodeIsLeaf, libscip), Cuint, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeIsLeftchild(node) + ccall((:SCIPbtnodeIsLeftchild, libscip), Cuint, (Ptr{SCIP_BTNODE},), node) +end + +function SCIPbtnodeIsRightchild(node) + ccall((:SCIPbtnodeIsRightchild, libscip), Cuint, (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{Libc.FILE}), tree, file) +end + +function SCIPbtIsEmpty(tree) + ccall((:SCIPbtIsEmpty, libscip), Cuint, (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, Cuint), 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 SCIPcalcFibHash(v) + ccall((:SCIPcalcFibHash, libscip), Cuint, (Cdouble,), v) +end + +function SCIPrealToRational(val, mindelta, maxdelta, maxdnom, numerator, denominator) + ccall((:SCIPrealToRational, libscip), Cuint, (Cdouble, Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), val, mindelta, maxdelta, maxdnom, numerator, denominator) +end + +function SCIPrealIsExactlyIntegral(val) + ccall((:SCIPrealIsExactlyIntegral, libscip), Cuint, (Cdouble,), val) +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{Cuint}), vals, nvals, mindelta, maxdelta, maxdnom, maxscale, intscalar, success) +end + +function SCIPcalcIntegralScalarExact(buffer, vals, nvals, maxscale, intscalar, success) + ccall((:SCIPcalcIntegralScalarExact, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Cint, Cdouble, Ptr{SCIP_RATIONAL}, Ptr{Cuint}), buffer, vals, nvals, maxscale, intscalar, success) +end + +function SCIPfindSimpleRational(lb, ub, maxdnom, numerator, denominator) + ccall((:SCIPfindSimpleRational, libscip), Cuint, (Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), lb, ub, maxdnom, numerator, denominator) +end + +function SCIPselectSimpleValue(lb, ub, maxdnom) + ccall((:SCIPselectSimpleValue, libscip), Cdouble, (Cdouble, Cdouble, Clonglong), lb, ub, maxdnom) +end + +function SCIPcalcRootNewton(_function, derivative, params, nparams, x, eps, k) + ccall((:SCIPcalcRootNewton, libscip), Cdouble, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cdouble}, Cint, Cdouble, Cdouble, Cint), _function, derivative, params, nparams, x, eps, k) +end + +function SCIPrelDiff(val1, val2) + ccall((:SCIPrelDiff, libscip), Cdouble, (Cdouble, Cdouble), val1, val2) end -function SCIPexprhdlrGetNReversepropCalls(exprhdlr) - ccall( - (:SCIPexprhdlrGetNReversepropCalls, libscip), - Clonglong, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPcomputeGap(eps, inf, primalbound, dualbound) + ccall((:SCIPcomputeGap, libscip), Cdouble, (Cdouble, Cdouble, Cdouble, Cdouble), eps, inf, primalbound, dualbound) end -function SCIPexprhdlrGetReversepropTime(exprhdlr) - ccall( - (:SCIPexprhdlrGetReversepropTime, libscip), - Cdouble, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPrandomGetInt(randnumgen, minrandval, maxrandval) + ccall((:SCIPrandomGetInt, libscip), Cint, (Ptr{SCIP_RANDNUMGEN}, Cint, Cint), randnumgen, minrandval, maxrandval) end -function SCIPexprhdlrGetNCutoffs(exprhdlr) - ccall( - (:SCIPexprhdlrGetNCutoffs, libscip), - Clonglong, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPrandomGetSubset(randnumgen, set, nelems, subset, nsubelems) + ccall((:SCIPrandomGetSubset, libscip), SCIP_RETCODE, (Ptr{SCIP_RANDNUMGEN}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Ptr{Cvoid}}, Cint), randnumgen, set, nelems, subset, nsubelems) end -function SCIPexprhdlrGetNDomainReductions(exprhdlr) - ccall( - (:SCIPexprhdlrGetNDomainReductions, libscip), - Clonglong, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPrandomGetReal(randnumgen, minrandval, maxrandval) + ccall((:SCIPrandomGetReal, libscip), Cdouble, (Ptr{SCIP_RANDNUMGEN}, Cdouble, Cdouble), randnumgen, minrandval, maxrandval) end -function SCIPexprhdlrIncrementNDomainReductions(exprhdlr, nreductions) - ccall( - (:SCIPexprhdlrIncrementNDomainReductions, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR}, Cint), - exprhdlr, - nreductions, - ) +function SCIPswapInts(value1, value2) + ccall((:SCIPswapInts, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}), value1, value2) end -function SCIPexprhdlrGetNEstimateCalls(exprhdlr) - ccall( - (:SCIPexprhdlrGetNEstimateCalls, libscip), - Clonglong, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPswapReals(value1, value2) + ccall((:SCIPswapReals, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}), value1, value2) end -function SCIPexprhdlrGetEstimateTime(exprhdlr) - ccall( - (:SCIPexprhdlrGetEstimateTime, libscip), - Cdouble, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPswapPointers(pointer1, pointer2) + ccall((:SCIPswapPointers, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}), pointer1, pointer2) end -function SCIPexprhdlrGetNBranchings(exprhdlr) - ccall( - (:SCIPexprhdlrGetNBranchings, libscip), - Clonglong, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPrandomPermuteIntArray(randnumgen, array, _begin, _end) + ccall((:SCIPrandomPermuteIntArray, libscip), Cvoid, (Ptr{SCIP_RANDNUMGEN}, Ptr{Cint}, Cint, Cint), randnumgen, array, _begin, _end) end -function SCIPexprhdlrIncrementNBranchings(exprhdlr) - ccall( - (:SCIPexprhdlrIncrementNBranchings, libscip), - Cvoid, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPrandomPermuteArray(randnumgen, array, _begin, _end) + ccall((:SCIPrandomPermuteArray, libscip), Cvoid, (Ptr{SCIP_RANDNUMGEN}, Ptr{Ptr{Cvoid}}, Cint, Cint), randnumgen, array, _begin, _end) end -function SCIPexprhdlrGetNSimplifyCalls(exprhdlr) - ccall( - (:SCIPexprhdlrGetNSimplifyCalls, libscip), - Clonglong, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPcomputeArraysIntersectionInt(array1, narray1, array2, narray2, intersectarray, nintersectarray) + ccall((:SCIPcomputeArraysIntersectionInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), array1, narray1, array2, narray2, intersectarray, nintersectarray) end -function SCIPexprhdlrGetSimplifyTime(exprhdlr) - ccall( - (:SCIPexprhdlrGetSimplifyTime, libscip), - Cdouble, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPcomputeArraysIntersectionPtr(array1, narray1, array2, narray2, ptrcomp, intersectarray, nintersectarray) + ccall((:SCIPcomputeArraysIntersectionPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Cint, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cvoid}, Ptr{Ptr{Cvoid}}, Ptr{Cint}), array1, narray1, array2, narray2, ptrcomp, intersectarray, nintersectarray) end -function SCIPexprhdlrGetNSimplifications(exprhdlr) - ccall( - (:SCIPexprhdlrGetNSimplifications, libscip), - Clonglong, - (Ptr{SCIP_EXPRHDLR},), - exprhdlr, - ) +function SCIPcomputeArraysSetminusInt(array1, narray1, array2, narray2, setminusarray, nsetminusarray) + ccall((:SCIPcomputeArraysSetminusInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), array1, narray1, array2, narray2, setminusarray, nsetminusarray) end -function SCIPexprGetNUses(expr) - ccall((:SCIPexprGetNUses, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +function SCIPmemccpy(dest, src, stop, cnt) + ccall((:SCIPmemccpy, libscip), Cint, (Ptr{Cchar}, Ptr{Cchar}, Cchar, Cuint), dest, src, stop, cnt) end -function SCIPexprGetNChildren(expr) - ccall((:SCIPexprGetNChildren, libscip), Cint, (Ptr{SCIP_EXPR},), expr) +function SCIPprintSysError(message) + ccall((:SCIPprintSysError, libscip), Cvoid, (Ptr{Cchar},), message) end -function SCIPexprGetChildren(expr) - ccall( - (:SCIPexprGetChildren, libscip), - Ptr{Ptr{SCIP_EXPR}}, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPstrtok(s, delim, ptrptr) + ccall((:SCIPstrtok, libscip), Ptr{Cchar}, (Ptr{Cchar}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), s, delim, ptrptr) end -function SCIPexprGetHdlr(expr) - ccall( - (:SCIPexprGetHdlr, libscip), - Ptr{SCIP_EXPRHDLR}, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPescapeString(t, bufsize, s) + ccall((:SCIPescapeString, libscip), Cvoid, (Ptr{Cchar}, Cint, Ptr{Cchar}), t, bufsize, s) end -function SCIPexprGetData(expr) - ccall( - (:SCIPexprGetData, libscip), - Ptr{SCIP_EXPRDATA}, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPskipSpace(s) + ccall((:SCIPskipSpace, libscip), SCIP_RETCODE, (Ptr{Ptr{Cchar}},), s) end -function SCIPexprSetData(expr, exprdata) - ccall( - (:SCIPexprSetData, libscip), - Cvoid, - (Ptr{SCIP_EXPR}, Ptr{SCIP_EXPRDATA}), - expr, - exprdata, - ) +function SCIPstrncpy(t, s, size) + ccall((:SCIPstrncpy, libscip), Cint, (Ptr{Cchar}, Ptr{Cchar}, Cint), t, s, size) end -function SCIPexprGetOwnerData(expr) - ccall( - (:SCIPexprGetOwnerData, libscip), - Ptr{SCIP_EXPR_OWNERDATA}, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPstrcasecmp(s1, s2) + ccall((:SCIPstrcasecmp, libscip), Cint, (Ptr{Cchar}, Ptr{Cchar}), s1, s2) end -function SCIPexprGetEvalValue(expr) - ccall((:SCIPexprGetEvalValue, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +function SCIPstrncasecmp(s1, s2, length) + ccall((:SCIPstrncasecmp, libscip), Cint, (Ptr{Cchar}, Ptr{Cchar}, Cint), s1, s2, length) end -function SCIPexprGetEvalTag(expr) - ccall((:SCIPexprGetEvalTag, libscip), Clonglong, (Ptr{SCIP_EXPR},), expr) +function SCIPstrToIntValue(str, value, endptr) + ccall((:SCIPstrToIntValue, libscip), Cuint, (Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{Cchar}}), str, value, endptr) end -function SCIPexprGetDerivative(expr) - ccall((:SCIPexprGetDerivative, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +function SCIPstrToRealValue(str, value, endptr) + ccall((:SCIPstrToRealValue, libscip), Cuint, (Ptr{Cchar}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), str, value, endptr) end -function SCIPexprGetDot(expr) - ccall((:SCIPexprGetDot, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +function SCIPstrCopySection(str, startchar, endchar, token, size, endptr) + ccall((:SCIPstrCopySection, libscip), Cvoid, (Ptr{Cchar}, Cchar, Cchar, Ptr{Cchar}, Cint, Ptr{Ptr{Cchar}}), str, startchar, endchar, token, size, endptr) end -function SCIPexprGetBardot(expr) - ccall((:SCIPexprGetBardot, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +function SCIPstrAtStart(s, t, tlen) + ccall((:SCIPstrAtStart, libscip), Cuint, (Ptr{Cchar}, Ptr{Cchar}, Csize_t), s, t, tlen) end -function SCIPexprGetDiffTag(expr) - ccall((:SCIPexprGetDiffTag, libscip), Clonglong, (Ptr{SCIP_EXPR},), expr) +function SCIPfileExists(filename) + ccall((:SCIPfileExists, libscip), Cuint, (Ptr{Cchar},), filename) end -function SCIPexprGetActivity(expr) - ccall( - (:SCIPexprGetActivity, libscip), - SCIP_INTERVAL, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPsplitFilename(filename, path, name, extension, compression) + ccall((:SCIPsplitFilename, libscip), Cvoid, (Ptr{Cchar}, Ptr{Ptr{Cchar}}, Ptr{Ptr{Cchar}}, Ptr{Ptr{Cchar}}, Ptr{Ptr{Cchar}}), filename, path, name, extension, compression) end -function SCIPexprGetActivityTag(expr) - ccall( - (:SCIPexprGetActivityTag, libscip), - Clonglong, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPconsGetRhs(scip, cons, success) + ccall((:SCIPconsGetRhs, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) end -function SCIPexprSetActivity(expr, activity, activitytag) - ccall( - (:SCIPexprSetActivity, libscip), - Cvoid, - (Ptr{SCIP_EXPR}, SCIP_INTERVAL, Clonglong), - expr, - activity, - activitytag, - ) +function SCIPconsGetLhs(scip, cons, success) + ccall((:SCIPconsGetLhs, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) end -function SCIPexprGetCurvature(expr) - ccall( - (:SCIPexprGetCurvature, libscip), - SCIP_EXPRCURV, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPconsGetRhsExact(scip, cons, success) + ccall((:SCIPconsGetRhsExact, libscip), Ptr{Cint}, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) end -function SCIPexprSetCurvature(expr, curvature) - ccall( - (:SCIPexprSetCurvature, libscip), - Cvoid, - (Ptr{SCIP_EXPR}, SCIP_EXPRCURV), - expr, - curvature, - ) +function SCIPconsGetLhsExact(scip, cons, success) + ccall((:SCIPconsGetLhsExact, libscip), Ptr{Cint}, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) end -function SCIPexprIsIntegral(expr) - ccall((:SCIPexprIsIntegral, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) +function SCIPgetConsVals(scip, cons, vals, varssize, success) + ccall((:SCIPgetConsVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Cint, Ptr{Cuint}), scip, cons, vals, varssize, success) end -function SCIPexprSetIntegrality(expr, isintegral) - ccall( - (:SCIPexprSetIntegrality, libscip), - Cvoid, - (Ptr{SCIP_EXPR}, Cuint), - expr, - isintegral, - ) -end - -function SCIPexprGetQuadraticData( - expr, - constant, - nlinexprs, - linexprs, - lincoefs, - nquadexprs, - nbilinexprs, - eigenvalues, - eigenvectors, -) - ccall( - (:SCIPexprGetQuadraticData, libscip), - Cvoid, - ( - Ptr{SCIP_EXPR}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Ptr{Ptr{SCIP_EXPR}}}, - Ptr{Ptr{Cdouble}}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Ptr{Cdouble}}, - Ptr{Ptr{Cdouble}}, - ), - expr, - constant, - nlinexprs, - linexprs, - lincoefs, - nquadexprs, - nbilinexprs, - eigenvalues, - eigenvectors, - ) -end - -function SCIPexprGetQuadraticQuadTerm( - quadexpr, - termidx, - expr, - lincoef, - sqrcoef, - nadjbilin, - adjbilin, - sqrexpr, -) - ccall( - (:SCIPexprGetQuadraticQuadTerm, libscip), - Cvoid, - ( - Ptr{SCIP_EXPR}, - Cint, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Ptr{Cint}}, - Ptr{Ptr{SCIP_EXPR}}, - ), - quadexpr, - termidx, - expr, - lincoef, - sqrcoef, - nadjbilin, - adjbilin, - sqrexpr, - ) -end - -function SCIPexprGetQuadraticBilinTerm( - expr, - termidx, - expr1, - expr2, - coef, - pos2, - prodexpr, -) - ccall( - (:SCIPexprGetQuadraticBilinTerm, libscip), - Cvoid, - ( - Ptr{SCIP_EXPR}, - Cint, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Ptr{SCIP_EXPR}}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Ptr{SCIP_EXPR}}, - ), - expr, - termidx, - expr1, - expr2, - coef, - pos2, - prodexpr, - ) +function SCIPgetConsValsExact(scip, cons, vals, varssize, success) + ccall((:SCIPgetConsValsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{Cint}}, Cint, Ptr{Cuint}), scip, cons, vals, varssize, success) end -function SCIPexprAreQuadraticExprsVariables(expr) - ccall( - (:SCIPexprAreQuadraticExprsVariables, libscip), - Cuint, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPconsGetDualfarkas(scip, cons, dualfarkas, success) + ccall((:SCIPconsGetDualfarkas, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), scip, cons, dualfarkas, success) end -function SCIPgetVarExprVar(expr) - ccall((:SCIPgetVarExprVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_EXPR},), expr) +function SCIPconsGetDualsol(scip, cons, dualsol, success) + ccall((:SCIPconsGetDualsol, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), scip, cons, dualsol, success) end -function SCIPgetValueExprValue(expr) - ccall((:SCIPgetValueExprValue, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +function SCIPconsGetRow(scip, cons) + ccall((:SCIPconsGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) end -function SCIPgetCoefsExprSum(expr) - ccall( - (:SCIPgetCoefsExprSum, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_EXPR},), - expr, - ) +function SCIPconsCreateRow(scip, cons, row) + ccall((:SCIPconsCreateRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_ROW}}), scip, cons, row) end -function SCIPgetConstantExprSum(expr) - ccall((:SCIPgetConstantExprSum, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +function SCIPconsAddCoef(scip, cons, var, val) + ccall((:SCIPconsAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, val) end -function SCIPgetCoefExprProduct(expr) - ccall((:SCIPgetCoefExprProduct, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +function SCIPcreateRowprep(scip, rowprep, sidetype, _local) + ccall((:SCIPcreateRowprep, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}, SCIP_SIDETYPE, Cuint), scip, rowprep, sidetype, _local) end -function SCIPgetExponentExprPow(expr) - ccall((:SCIPgetExponentExprPow, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) +function SCIPfreeRowprep(scip, rowprep) + ccall((:SCIPfreeRowprep, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}), scip, rowprep) end -function SCIPexpriterIsInit(iterator) - ccall( - (:SCIPexpriterIsInit, libscip), - Cuint, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIPcopyRowprep(scip, target, source) + ccall((:SCIPcopyRowprep, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}, Ptr{SCIP_ROWPREP}), scip, target, source) end -function SCIPexpriterInit(iterator, expr, type, allowrevisit) - ccall( - (:SCIPexpriterInit, libscip), - SCIP_RETCODE, - (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_TYPE, Cuint), - iterator, - expr, - type, - allowrevisit, - ) +function SCIProwprepGetNVars(rowprep) + ccall((:SCIProwprepGetNVars, libscip), Cint, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterRestartDFS(iterator, expr) - ccall( - (:SCIPexpriterRestartDFS, libscip), - Ptr{SCIP_EXPR}, - (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}), - iterator, - expr, - ) +function SCIProwprepGetVars(rowprep) + ccall((:SCIProwprepGetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterSetStagesDFS(iterator, stopstages) - ccall( - (:SCIPexpriterSetStagesDFS, libscip), - Cvoid, - (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_STAGE), - iterator, - stopstages, - ) +function SCIProwprepGetCoefs(rowprep) + ccall((:SCIProwprepGetCoefs, libscip), Ptr{Cdouble}, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterGetCurrent(iterator) - ccall( - (:SCIPexpriterGetCurrent, libscip), - Ptr{SCIP_EXPR}, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepGetSide(rowprep) + ccall((:SCIProwprepGetSide, libscip), Cdouble, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterGetStageDFS(iterator) - ccall( - (:SCIPexpriterGetStageDFS, libscip), - SCIP_EXPRITER_STAGE, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepGetSidetype(rowprep) + ccall((:SCIProwprepGetSidetype, libscip), SCIP_SIDETYPE, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterGetChildIdxDFS(iterator) - ccall( - (:SCIPexpriterGetChildIdxDFS, libscip), - Cint, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepIsLocal(rowprep) + ccall((:SCIProwprepIsLocal, libscip), Cuint, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterGetChildExprDFS(iterator) - ccall( - (:SCIPexpriterGetChildExprDFS, libscip), - Ptr{SCIP_EXPR}, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepGetName(rowprep) + ccall((:SCIProwprepGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterGetParentDFS(iterator) - ccall( - (:SCIPexpriterGetParentDFS, libscip), - Ptr{SCIP_EXPR}, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepGetNModifiedVars(rowprep) + ccall((:SCIProwprepGetNModifiedVars, libscip), Cint, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterGetCurrentUserData(iterator) - ccall( - (:SCIPexpriterGetCurrentUserData, libscip), - SCIP_EXPRITER_USERDATA, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepGetModifiedVars(rowprep) + ccall((:SCIProwprepGetModifiedVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterGetChildUserDataDFS(iterator) - ccall( - (:SCIPexpriterGetChildUserDataDFS, libscip), - SCIP_EXPRITER_USERDATA, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepReset(rowprep) + ccall((:SCIProwprepReset, libscip), Cvoid, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterGetExprUserData(iterator, expr) - ccall( - (:SCIPexpriterGetExprUserData, libscip), - SCIP_EXPRITER_USERDATA, - (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}), - iterator, - expr, - ) +function SCIProwprepSetCoef(rowprep, idx, newcoef) + ccall((:SCIProwprepSetCoef, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, Cint, Cdouble), rowprep, idx, newcoef) end -function SCIPexpriterSetCurrentUserData(iterator, userdata) - ccall( - (:SCIPexpriterSetCurrentUserData, libscip), - Cvoid, - (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_USERDATA), - iterator, - userdata, - ) +function SCIProwprepAddSide(rowprep, side) + ccall((:SCIProwprepAddSide, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, Cdouble), rowprep, side) end -function SCIPexpriterSetExprUserData(iterator, expr, userdata) - ccall( - (:SCIPexpriterSetExprUserData, libscip), - Cvoid, - (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_USERDATA), - iterator, - expr, - userdata, - ) +function SCIProwprepAddConstant(rowprep, constant) + ccall((:SCIProwprepAddConstant, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, Cdouble), rowprep, constant) end -function SCIPexpriterSetChildUserData(iterator, userdata) - ccall( - (:SCIPexpriterSetChildUserData, libscip), - Cvoid, - (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_USERDATA), - iterator, - userdata, - ) +function SCIProwprepSetSidetype(rowprep, sidetype) + ccall((:SCIProwprepSetSidetype, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, SCIP_SIDETYPE), rowprep, sidetype) end -function SCIPexpriterGetNext(iterator) - ccall( - (:SCIPexpriterGetNext, libscip), - Ptr{SCIP_EXPR}, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepSetLocal(rowprep, islocal) + ccall((:SCIProwprepSetLocal, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, Cuint), rowprep, islocal) end -function SCIPexpriterSkipDFS(iterator) - ccall( - (:SCIPexpriterSkipDFS, libscip), - Ptr{SCIP_EXPR}, - (Ptr{SCIP_EXPRITER},), - iterator, - ) +function SCIProwprepRecordModifications(rowprep) + ccall((:SCIProwprepRecordModifications, libscip), Cvoid, (Ptr{SCIP_ROWPREP},), rowprep) end -function SCIPexpriterIsEnd(iterator) - ccall((:SCIPexpriterIsEnd, libscip), Cuint, (Ptr{SCIP_EXPRITER},), iterator) +function SCIPprintRowprep(scip, rowprep, file) + ccall((:SCIPprintRowprep, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{Libc.FILE}), scip, rowprep, file) end -function SCIPexprcurvAdd(curv1, curv2) - ccall( - (:SCIPexprcurvAdd, libscip), - SCIP_EXPRCURV, - (SCIP_EXPRCURV, SCIP_EXPRCURV), - curv1, - curv2, - ) +function SCIPprintRowprepSol(scip, rowprep, sol, file) + ccall((:SCIPprintRowprepSol, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), scip, rowprep, sol, file) end -function SCIPexprcurvNegate(curvature) - ccall( - (:SCIPexprcurvNegate, libscip), - SCIP_EXPRCURV, - (SCIP_EXPRCURV,), - curvature, - ) +function SCIPensureRowprepSize(scip, rowprep, size) + ccall((:SCIPensureRowprepSize, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cint), scip, rowprep, size) end -function SCIPexprcurvMultiply(factor, curvature) - ccall( - (:SCIPexprcurvMultiply, libscip), - SCIP_EXPRCURV, - (Cdouble, SCIP_EXPRCURV), - factor, - curvature, - ) +function SCIPaddRowprepTerm(scip, rowprep, var, coef) + ccall((:SCIPaddRowprepTerm, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_VAR}, Cdouble), scip, rowprep, var, coef) end -function SCIPexprcurvPower(basebounds, basecurv, exponent) - ccall( - (:SCIPexprcurvPower, libscip), - SCIP_EXPRCURV, - (SCIP_INTERVAL, SCIP_EXPRCURV, Cdouble), - basebounds, - basecurv, - exponent, - ) +function SCIPaddRowprepTerms(scip, rowprep, nvars, vars, coefs) + ccall((:SCIPaddRowprepTerms, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, rowprep, nvars, vars, coefs) end -function SCIPexprcurvPowerInv(basebounds, exponent, powercurv) - ccall( - (:SCIPexprcurvPowerInv, libscip), - SCIP_EXPRCURV, - (SCIP_INTERVAL, Cdouble, SCIP_EXPRCURV), - basebounds, - exponent, - powercurv, - ) -end - -function SCIPexprcurvMonomial( - nfactors, - exponents, - factoridxs, - factorcurv, - factorbounds, -) - ccall( - (:SCIPexprcurvMonomial, libscip), - SCIP_EXPRCURV, - (Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{SCIP_EXPRCURV}, Ptr{SCIP_INTERVAL}), - nfactors, - exponents, - factoridxs, - factorcurv, - factorbounds, - ) -end - -function SCIPexprcurvMonomialInv( - monomialcurv, - nfactors, - exponents, - factorbounds, - factorcurv, -) - ccall( - (:SCIPexprcurvMonomialInv, libscip), - Cuint, - ( - SCIP_EXPRCURV, - Cint, - Ptr{Cdouble}, - Ptr{SCIP_INTERVAL}, - Ptr{SCIP_EXPRCURV}, - ), - monomialcurv, - nfactors, - exponents, - factorbounds, - factorcurv, - ) +function SCIPgetRowprepViolation(scip, rowprep, sol, reliable) + ccall((:SCIPgetRowprepViolation, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, rowprep, sol, reliable) end -function SCIPexprcurvGetName(curv) - ccall((:SCIPexprcurvGetName, libscip), Ptr{Cchar}, (SCIP_EXPRCURV,), curv) +function SCIPisRowprepViolationReliable(scip, rowprep, sol) + ccall((:SCIPisRowprepViolationReliable, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}), scip, rowprep, sol) end -const SCIP_File = Cvoid - -const SCIP_FILE = SCIP_File - -function SCIPfopen(path, mode) - ccall( - (:SCIPfopen, libscip), - Ptr{SCIP_FILE}, - (Ptr{Cchar}, Ptr{Cchar}), - path, - mode, - ) +function SCIPmergeRowprepTerms(scip, rowprep) + ccall((:SCIPmergeRowprepTerms, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}), scip, rowprep) end -function SCIPfdopen(fildes, mode) - ccall( - (:SCIPfdopen, libscip), - Ptr{SCIP_FILE}, - (Cint, Ptr{Cchar}), - fildes, - mode, - ) +function SCIPcleanupRowprep(scip, rowprep, sol, minviol, viol, success) + ccall((:SCIPcleanupRowprep, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Cdouble, Ptr{Cdouble}, Ptr{Cuint}), scip, rowprep, sol, minviol, viol, success) 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, - ) +function SCIPcleanupRowprep2(scip, rowprep, sol, maxcoefbound, success) + ccall((:SCIPcleanupRowprep2, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Cdouble, Ptr{Cuint}), scip, rowprep, sol, maxcoefbound, success) 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, - ) +function SCIPscaleupRowprep(scip, rowprep, minscaleup, success) + ccall((:SCIPscaleupRowprep, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cdouble, Ptr{Cuint}), scip, rowprep, minscaleup, success) end -function SCIPfputc(c, stream) - ccall((:SCIPfputc, libscip), Cint, (Cint, Ptr{SCIP_FILE}), c, stream) +function SCIPscaleRowprep(rowprep, factor) + ccall((:SCIPscaleRowprep, libscip), Cint, (Ptr{SCIP_ROWPREP}, Cdouble), rowprep, factor) end -function SCIPfputs(s, stream) - ccall((:SCIPfputs, libscip), Cint, (Ptr{Cchar}, Ptr{SCIP_FILE}), s, stream) +function SCIPgetRowprepRowConshdlr(scip, row, rowprep, conshdlr) + ccall((:SCIPgetRowprepRowConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_CONSHDLR}), scip, row, rowprep, conshdlr) end -function SCIPfgetc(stream) - ccall((:SCIPfgetc, libscip), Cint, (Ptr{SCIP_FILE},), stream) +function SCIPgetRowprepRowCons(scip, row, rowprep, cons) + ccall((:SCIPgetRowprepRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_CONS}), scip, row, rowprep, cons) end -function SCIPfgets(s, size, stream) - ccall( - (:SCIPfgets, libscip), - Ptr{Cchar}, - (Ptr{Cchar}, Cint, Ptr{SCIP_FILE}), - s, - size, - stream, - ) +function SCIPgetRowprepRowSepa(scip, row, rowprep, sepa) + ccall((:SCIPgetRowprepRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SEPA}), scip, row, rowprep, sepa) end -function SCIPfflush(stream) - ccall((:SCIPfflush, libscip), Cint, (Ptr{SCIP_FILE},), stream) +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 SCIPfseek(stream, offset, whence) - ccall( - (:SCIPfseek, libscip), - Cint, - (Ptr{SCIP_FILE}, Clong, Cint), - stream, - offset, - whence, - ) +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 SCIPrewind(stream) - ccall((:SCIPrewind, libscip), Cvoid, (Ptr{SCIP_FILE},), stream) +function SCIPselectPtr(ptrarray, ptrcomp, k, len) + ccall((:SCIPselectPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Cint), ptrarray, ptrcomp, k, len) end -function SCIPftell(stream) - ccall((:SCIPftell, libscip), Clong, (Ptr{SCIP_FILE},), stream) +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 SCIPfeof(stream) - ccall((:SCIPfeof, libscip), Cint, (Ptr{SCIP_FILE},), stream) +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 SCIPfclose(fp) - ccall((:SCIPfclose, libscip), Cint, (Ptr{SCIP_FILE},), fp) +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 SCIPheurComp(elem1, elem2) - ccall( - (:SCIPheurComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +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 SCIPheurCompName(elem1, elem2) - ccall( - (:SCIPheurCompName, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +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 SCIPheurGetData(heur) - ccall( - (:SCIPheurGetData, libscip), - Ptr{SCIP_HEURDATA}, - (Ptr{SCIP_HEUR},), - heur, - ) +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 SCIPheurSetData(heur, heurdata) - ccall( - (:SCIPheurSetData, libscip), - Cvoid, - (Ptr{SCIP_HEUR}, Ptr{SCIP_HEURDATA}), - heur, - heurdata, - ) +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 SCIPheurGetName(heur) - ccall((:SCIPheurGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_HEUR},), heur) +function SCIPselectPtrBool(ptrarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, boolarray, ptrcomp, k, len) end -function SCIPheurGetDesc(heur) - ccall((:SCIPheurGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_HEUR},), heur) +function SCIPselectWeightedPtrBool(ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) end -function SCIPheurGetDispchar(heur) - ccall((:SCIPheurGetDispchar, libscip), Cchar, (Ptr{SCIP_HEUR},), heur) +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 SCIPheurGetTimingmask(heur) - ccall( - (:SCIPheurGetTimingmask, libscip), - SCIP_HEURTIMING, - (Ptr{SCIP_HEUR},), - heur, - ) +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 SCIPheurSetTimingmask(heur, timingmask) - ccall( - (:SCIPheurSetTimingmask, libscip), - Cvoid, - (Ptr{SCIP_HEUR}, SCIP_HEURTIMING), - heur, - timingmask, - ) +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 SCIPheurUsesSubscip(heur) - ccall((:SCIPheurUsesSubscip, libscip), Cuint, (Ptr{SCIP_HEUR},), heur) +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 SCIPheurGetPriority(heur) - ccall((:SCIPheurGetPriority, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +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 SCIPheurGetFreq(heur) - ccall((:SCIPheurGetFreq, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +function SCIPselectPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, k, len) end -function SCIPheurSetFreq(heur, freq) - ccall( - (:SCIPheurSetFreq, libscip), - Cvoid, - (Ptr{SCIP_HEUR}, Cint), - heur, - freq, - ) +function SCIPselectPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, k, len) end -function SCIPheurGetFreqofs(heur) - ccall((:SCIPheurGetFreqofs, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +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 SCIPheurGetMaxdepth(heur) - ccall((:SCIPheurGetMaxdepth, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +function SCIPselectWeightedPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) end -function SCIPheurGetNCalls(heur) - ccall((:SCIPheurGetNCalls, libscip), Clonglong, (Ptr{SCIP_HEUR},), heur) +function SCIPselectWeightedPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, weights, capacity, len, medianpos) end -function SCIPheurGetNSolsFound(heur) - ccall((:SCIPheurGetNSolsFound, libscip), Clonglong, (Ptr{SCIP_HEUR},), heur) +function SCIPselectPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, boolarray, ptrcomp, k, len) end -function SCIPheurGetNBestSolsFound(heur) - ccall( - (:SCIPheurGetNBestSolsFound, libscip), - Clonglong, - (Ptr{SCIP_HEUR},), - heur, - ) +function SCIPselectWeightedPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) end -function SCIPheurIsInitialized(heur) - ccall((:SCIPheurIsInitialized, libscip), Cuint, (Ptr{SCIP_HEUR},), heur) +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 SCIPheurGetSetupTime(heur) - ccall((:SCIPheurGetSetupTime, libscip), Cdouble, (Ptr{SCIP_HEUR},), heur) +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 SCIPheurGetTime(heur) - ccall((:SCIPheurGetTime, libscip), Cdouble, (Ptr{SCIP_HEUR},), heur) +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 SCIPheurGetDivesets(heur) - ccall( - (:SCIPheurGetDivesets, libscip), - Ptr{Ptr{SCIP_DIVESET}}, - (Ptr{SCIP_HEUR},), - heur, - ) +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 SCIPheurGetNDivesets(heur) - ccall((:SCIPheurGetNDivesets, libscip), Cint, (Ptr{SCIP_HEUR},), heur) +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 SCIPdivesetGetHeur(diveset) - ccall( - (:SCIPdivesetGetHeur, libscip), - Ptr{SCIP_HEUR}, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetGetWorkSolution(diveset) - ccall( - (:SCIPdivesetGetWorkSolution, libscip), - Ptr{SCIP_SOL}, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetSetWorkSolution(diveset, sol) - ccall( - (:SCIPdivesetSetWorkSolution, libscip), - Cvoid, - (Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}), - diveset, - sol, - ) +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 SCIPdivesetGetName(diveset) - ccall( - (:SCIPdivesetGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetGetMinRelDepth(diveset) - ccall( - (:SCIPdivesetGetMinRelDepth, libscip), - Cdouble, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetGetMaxRelDepth(diveset) - ccall( - (:SCIPdivesetGetMaxRelDepth, libscip), - Cdouble, - (Ptr{SCIP_DIVESET},), - diveset, - ) +function SCIPselectPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) end -function SCIPdivesetGetSolSuccess(diveset, divecontext) - ccall( - (:SCIPdivesetGetSolSuccess, libscip), - Clonglong, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +function SCIPselectWeightedPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) end -function SCIPdivesetGetNCalls(diveset, divecontext) - ccall( - (:SCIPdivesetGetNCalls, libscip), - Cint, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetNSolutionCalls(diveset, divecontext) - ccall( - (:SCIPdivesetGetNSolutionCalls, libscip), - Cint, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetMinDepth(diveset, divecontext) - ccall( - (:SCIPdivesetGetMinDepth, libscip), - Cint, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetMaxDepth(diveset, divecontext) - ccall( - (:SCIPdivesetGetMaxDepth, libscip), - Cint, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetAvgDepth(diveset, divecontext) - ccall( - (:SCIPdivesetGetAvgDepth, libscip), - Cdouble, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +function SCIPselectReal(realarray, k, len) + ccall((:SCIPselectReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Cint), realarray, k, len) end -function SCIPdivesetGetMinSolutionDepth(diveset, divecontext) - ccall( - (:SCIPdivesetGetMinSolutionDepth, libscip), - Cint, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetMaxSolutionDepth(diveset, divecontext) - ccall( - (:SCIPdivesetGetMaxSolutionDepth, libscip), - Cint, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +function SCIPselectRealPtr(realarray, ptrarray, k, len) + ccall((:SCIPselectRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, ptrarray, k, len) end -function SCIPdivesetGetAvgSolutionDepth(diveset, divecontext) - ccall( - (:SCIPdivesetGetAvgSolutionDepth, libscip), - Cdouble, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetNLPIterations(diveset, divecontext) - ccall( - (:SCIPdivesetGetNLPIterations, libscip), - Clonglong, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +function SCIPselectRealInt(realarray, intarray, k, len) + ccall((:SCIPselectRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray, intarray, k, len) end -function SCIPdivesetGetNProbingNodes(diveset, divecontext) - ccall( - (:SCIPdivesetGetNProbingNodes, libscip), - Clonglong, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetNBacktracks(diveset, divecontext) - ccall( - (:SCIPdivesetGetNBacktracks, libscip), - Clonglong, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetNConflicts(diveset, divecontext) - ccall( - (:SCIPdivesetGetNConflicts, libscip), - Clonglong, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +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 SCIPdivesetGetNSols(diveset, divecontext) - ccall( - (:SCIPdivesetGetNSols, libscip), - Clonglong, - (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), - diveset, - divecontext, - ) +function SCIPselectRealBoolPtr(realarray, boolarray, ptrarray, k, len) + ccall((:SCIPselectRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, boolarray, ptrarray, k, len) end -function SCIPdivesetGetMaxLPIterQuot(diveset) - ccall( - (:SCIPdivesetGetMaxLPIterQuot, libscip), - Cdouble, - (Ptr{SCIP_DIVESET},), - diveset, - ) +function SCIPselectWeightedRealBoolPtr(realarray, boolarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, weights, capacity, len, medianpos) end -function SCIPdivesetGetMaxLPIterOffset(diveset) - ccall( - (:SCIPdivesetGetMaxLPIterOffset, libscip), - Cint, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetGetUbQuotNoSol(diveset) - ccall( - (:SCIPdivesetGetUbQuotNoSol, libscip), - Cdouble, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetGetAvgQuotNoSol(diveset) - ccall( - (:SCIPdivesetGetAvgQuotNoSol, libscip), - Cdouble, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetGetUbQuot(diveset) - ccall( - (:SCIPdivesetGetUbQuot, libscip), - Cdouble, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetGetAvgQuot(diveset) - ccall( - (:SCIPdivesetGetAvgQuot, libscip), - Cdouble, - (Ptr{SCIP_DIVESET},), - diveset, - ) +function SCIPselectRealPtrPtr(realarray, ptrarray1, ptrarray2, k, len) + ccall((:SCIPselectRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, ptrarray1, ptrarray2, k, len) end -function SCIPdivesetUseBacktrack(diveset) - ccall( - (:SCIPdivesetUseBacktrack, libscip), - Cuint, - (Ptr{SCIP_DIVESET},), - diveset, - ) +function SCIPselectWeightedRealPtrPtr(realarray, ptrarray1, ptrarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealPtrPtr, 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 SCIPdivesetGetLPSolveFreq(diveset) - ccall( - (:SCIPdivesetGetLPSolveFreq, libscip), - Cint, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetGetLPResolveDomChgQuot(diveset) - ccall( - (:SCIPdivesetGetLPResolveDomChgQuot, libscip), - Cdouble, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetUseOnlyLPBranchcands(diveset) - ccall( - (:SCIPdivesetUseOnlyLPBranchcands, libscip), - Cuint, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetSupportsType(diveset, divetype) - ccall( - (:SCIPdivesetSupportsType, libscip), - Cuint, - (Ptr{SCIP_DIVESET}, SCIP_DIVETYPE), - diveset, - divetype, - ) +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 SCIPdivesetGetRandnumgen(diveset) - ccall( - (:SCIPdivesetGetRandnumgen, libscip), - Ptr{SCIP_RANDNUMGEN}, - (Ptr{SCIP_DIVESET},), - diveset, - ) +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 SCIPdivesetIsPublic(diveset) - ccall((:SCIPdivesetIsPublic, libscip), Cuint, (Ptr{SCIP_DIVESET},), diveset) +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 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}}, Cuint, Cdouble, Ptr{Cint}), - scip, - vargraph, - relaxdenseconss, - relaxdensity, - nrelaxedconstraints, - ) +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 SCIPvariableGraphFree(scip, vargraph) - ccall( - (:SCIPvariableGraphFree, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{SCIP_VGRAPH}}), - scip, - vargraph, - ) +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 SCIPhistoryGetVSIDS(history, dir) - ccall( - (:SCIPhistoryGetVSIDS, libscip), - Cdouble, - (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), - history, - dir, - ) +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 SCIPhistoryGetCutoffSum(history, dir) - ccall( - (:SCIPhistoryGetCutoffSum, libscip), - Cdouble, - (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), - history, - dir, - ) +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 SCIPvaluehistoryGetNValues(valuehistory) - ccall( - (:SCIPvaluehistoryGetNValues, libscip), - Cint, - (Ptr{SCIP_VALUEHISTORY},), - valuehistory, - ) +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 SCIPvaluehistoryGetHistories(valuehistory) - ccall( - (:SCIPvaluehistoryGetHistories, libscip), - Ptr{Ptr{SCIP_HISTORY}}, - (Ptr{SCIP_VALUEHISTORY},), - valuehistory, - ) +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 SCIPvaluehistoryGetValues(valuehistory) - ccall( - (:SCIPvaluehistoryGetValues, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_VALUEHISTORY},), - valuehistory, - ) +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 SCIPcliqueSearchVar(clique, var, value) - ccall( - (:SCIPcliqueSearchVar, libscip), - Cint, - (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, Cuint), - clique, - var, - value, - ) +function SCIPselectRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) + ccall((:SCIPselectRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) end -function SCIPcliqueHasVar(clique, var, value) - ccall( - (:SCIPcliqueHasVar, libscip), - Cuint, - (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, Cuint), - clique, - var, - value, - ) +function SCIPselectWeightedRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) end -function SCIPcliqueGetNVars(clique) - ccall((:SCIPcliqueGetNVars, libscip), Cint, (Ptr{SCIP_CLIQUE},), clique) +function SCIPselectRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, k, len) + ccall((:SCIPselectRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, k, len) end -function SCIPcliqueGetVars(clique) - ccall( - (:SCIPcliqueGetVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_CLIQUE},), - clique, - ) +function SCIPselectWeightedRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, weights, capacity, len, medianpos) end -function SCIPcliqueGetValues(clique) - ccall( - (:SCIPcliqueGetValues, libscip), - Ptr{Cuint}, - (Ptr{SCIP_CLIQUE},), - clique, - ) +function SCIPselectInt(intarray, k, len) + ccall((:SCIPselectInt, libscip), Cvoid, (Ptr{Cint}, Cint, Cint), intarray, k, len) end -function SCIPcliqueGetId(clique) - ccall((:SCIPcliqueGetId, libscip), Cuint, (Ptr{SCIP_CLIQUE},), clique) +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 SCIPcliqueGetIndex(clique) - ccall((:SCIPcliqueGetIndex, libscip), Cint, (Ptr{SCIP_CLIQUE},), clique) +function SCIPselectIntInt(intarray1, intarray2, k, len) + ccall((:SCIPselectIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Cint), intarray1, intarray2, k, len) end -function SCIPcliqueIsCleanedUp(clique) - ccall((:SCIPcliqueIsCleanedUp, libscip), Cuint, (Ptr{SCIP_CLIQUE},), clique) +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 SCIPcliqueIsEquation(clique) - ccall((:SCIPcliqueIsEquation, libscip), Cuint, (Ptr{SCIP_CLIQUE},), clique) +function SCIPselectIntPtr(intarray, ptrarray, k, len) + ccall((:SCIPselectIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray, ptrarray, k, len) end -function SCIPcolSort(col) - ccall((:SCIPcolSort, libscip), Cvoid, (Ptr{SCIP_COL},), col) +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 SCIPcolGetObj(col) - ccall((:SCIPcolGetObj, libscip), Cdouble, (Ptr{SCIP_COL},), col) +function SCIPselectIntReal(intarray, realarray, k, len) + ccall((:SCIPselectIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray, realarray, k, len) end -function SCIPcolGetLb(col) - ccall((:SCIPcolGetLb, libscip), Cdouble, (Ptr{SCIP_COL},), col) +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 SCIPcolGetUb(col) - ccall((:SCIPcolGetUb, libscip), Cdouble, (Ptr{SCIP_COL},), col) +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 SCIPcolGetBestBound(col) - ccall((:SCIPcolGetBestBound, libscip), Cdouble, (Ptr{SCIP_COL},), col) +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 SCIPcolGetPrimsol(col) - ccall((:SCIPcolGetPrimsol, libscip), Cdouble, (Ptr{SCIP_COL},), col) +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 SCIPcolGetMinPrimsol(col) - ccall((:SCIPcolGetMinPrimsol, libscip), Cdouble, (Ptr{SCIP_COL},), col) +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 SCIPcolGetMaxPrimsol(col) - ccall((:SCIPcolGetMaxPrimsol, libscip), Cdouble, (Ptr{SCIP_COL},), col) +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 -@enum SCIP_BaseStat::UInt32 begin - SCIP_BASESTAT_LOWER = 0 - SCIP_BASESTAT_BASIC = 1 - SCIP_BASESTAT_UPPER = 2 - SCIP_BASESTAT_ZERO = 3 +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 -const SCIP_BASESTAT = SCIP_BaseStat +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 SCIPcolGetBasisStatus(col) - ccall( - (:SCIPcolGetBasisStatus, libscip), - SCIP_BASESTAT, - (Ptr{SCIP_COL},), - col, - ) +function SCIPselectIntIntPtrPtr(intarray1, intarray2, ptrarray1, ptrarray2, k, len) + ccall((:SCIPselectIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray1, intarray2, ptrarray1, ptrarray2, k, len) end -function SCIPcolGetVar(col) - ccall((:SCIPcolGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_COL},), col) +function SCIPselectIntIntPtrPtrInterval(intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, k, len) + ccall((:SCIPselectIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Cint, Cint), intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, k, len) end -function SCIPcolGetIndex(col) - ccall((:SCIPcolGetIndex, libscip), Cint, (Ptr{SCIP_COL},), col) +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 SCIPcolGetVarProbindex(col) - ccall((:SCIPcolGetVarProbindex, libscip), Cint, (Ptr{SCIP_COL},), col) +function SCIPselectWeightedIntIntPtrPtr(intarray1, intarray2, ptrarray1, ptrarray2, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, weights, capacity, len, medianpos) end -function SCIPcolIsIntegral(col) - ccall((:SCIPcolIsIntegral, libscip), Cuint, (Ptr{SCIP_COL},), col) +function SCIPselectWeightedIntIntPtrPtrInterval(intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, weights, capacity, len, medianpos) end -function SCIPcolIsRemovable(col) - ccall((:SCIPcolIsRemovable, libscip), Cuint, (Ptr{SCIP_COL},), col) +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 SCIPcolGetLPPos(col) - ccall((:SCIPcolGetLPPos, libscip), Cint, (Ptr{SCIP_COL},), col) +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 SCIPcolGetLPDepth(col) - ccall((:SCIPcolGetLPDepth, libscip), Cint, (Ptr{SCIP_COL},), col) +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 SCIPcolIsInLP(col) - ccall((:SCIPcolIsInLP, libscip), Cuint, (Ptr{SCIP_COL},), col) +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 SCIPcolGetNNonz(col) - ccall((:SCIPcolGetNNonz, libscip), Cint, (Ptr{SCIP_COL},), col) +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 SCIPcolGetNLPNonz(col) - ccall((:SCIPcolGetNLPNonz, libscip), Cint, (Ptr{SCIP_COL},), col) +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 SCIPcolGetRows(col) - ccall((:SCIPcolGetRows, libscip), Ptr{Ptr{SCIP_ROW}}, (Ptr{SCIP_COL},), col) +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 SCIPcolGetVals(col) - ccall((:SCIPcolGetVals, libscip), Ptr{Cdouble}, (Ptr{SCIP_COL},), col) +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 SCIPcolGetStrongbranchNode(col) - ccall( - (:SCIPcolGetStrongbranchNode, libscip), - Clonglong, - (Ptr{SCIP_COL},), - col, - ) +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 SCIPcolGetNStrongbranchs(col) - ccall((:SCIPcolGetNStrongbranchs, libscip), Cint, (Ptr{SCIP_COL},), col) +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 SCIPcolGetAge(col) - ccall((:SCIPcolGetAge, libscip), Cint, (Ptr{SCIP_COL},), col) +function SCIPselectLong(longarray, k, len) + ccall((:SCIPselectLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Cint), longarray, k, len) end -function SCIPboundtypeOpposite(boundtype) - ccall( - (:SCIPboundtypeOpposite, libscip), - SCIP_BOUNDTYPE, - (SCIP_BOUNDTYPE,), - boundtype, - ) +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 SCIProwComp(elem1, elem2) - ccall((:SCIProwComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) +function SCIPselectLongPtr(longarray, ptrarray, k, len) + ccall((:SCIPselectLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Cint), longarray, ptrarray, k, len) end -function SCIProwLock(row) - ccall((:SCIProwLock, libscip), Cvoid, (Ptr{SCIP_ROW},), row) +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 SCIProwUnlock(row) - ccall((:SCIProwUnlock, libscip), Cvoid, (Ptr{SCIP_ROW},), row) +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 SCIProwGetScalarProduct(row1, row2) - ccall( - (:SCIProwGetScalarProduct, libscip), - Cdouble, - (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}), - row1, - row2, - ) +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 SCIProwGetParallelism(row1, row2, orthofunc) - ccall( - (:SCIProwGetParallelism, libscip), - Cdouble, - (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Cchar), - row1, - row2, - orthofunc, - ) +function SCIPselectLongPtrRealBool(longarray, ptrarray, realarray, boolarray, k, len) + ccall((:SCIPselectLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Cint), longarray, ptrarray, realarray, boolarray, k, len) end -function SCIProwGetOrthogonality(row1, row2, orthofunc) - ccall( - (:SCIProwGetOrthogonality, libscip), - Cdouble, - (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Cchar), - row1, - row2, - orthofunc, - ) +function SCIPselectWeightedLongPtrRealBool(longarray, ptrarray, realarray, boolarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, weights, capacity, len, medianpos) end -function SCIProwSort(row) - ccall((:SCIProwSort, libscip), Cvoid, (Ptr{SCIP_ROW},), row) +function SCIPselectLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, k, len) + ccall((:SCIPselectLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Cint), longarray, ptrarray, realarray, realarray2, boolarray, k, len) end -function SCIProwGetNNonz(row) - ccall((:SCIProwGetNNonz, libscip), Cint, (Ptr{SCIP_ROW},), row) +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{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, weights, capacity, len, medianpos) end -function SCIProwGetNLPNonz(row) - ccall((:SCIProwGetNLPNonz, libscip), Cint, (Ptr{SCIP_ROW},), row) +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{Cuint}, Cint, Cint), longarray, ptrarray, realarray, realarray2, intarray, boolarray, k, len) end -function SCIProwGetCols(row) - ccall((:SCIProwGetCols, libscip), Ptr{Ptr{SCIP_COL}}, (Ptr{SCIP_ROW},), row) +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{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, weights, capacity, len, medianpos) end -function SCIProwGetVals(row) - ccall((:SCIProwGetVals, libscip), Ptr{Cdouble}, (Ptr{SCIP_ROW},), row) +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 SCIProwGetConstant(row) - ccall((:SCIProwGetConstant, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +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 SCIProwGetNorm(row) - ccall((:SCIProwGetNorm, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +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 SCIProwGetSumNorm(row) - ccall((:SCIProwGetSumNorm, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +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 SCIProwGetLhs(row) - ccall((:SCIProwGetLhs, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +function SCIPselectLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, k, len) + ccall((:SCIPselectLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Cint, Cint), longarray, ptrarray1, ptrarray2, boolarray, intarray, k, len) end -function SCIProwGetRhs(row) - ccall((:SCIProwGetRhs, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +function SCIPselectWeightedLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, weights, capacity, len, medianpos) end -function SCIProwGetDualsol(row) - ccall((:SCIProwGetDualsol, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +function SCIPselectPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, k, len) + ccall((:SCIPselectPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, k, len) end -function SCIProwGetDualfarkas(row) - ccall((:SCIProwGetDualfarkas, libscip), Cdouble, (Ptr{SCIP_ROW},), row) +function SCIPselectWeightedPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) end -function SCIProwGetBasisStatus(row) - ccall( - (:SCIProwGetBasisStatus, libscip), - SCIP_BASESTAT, - (Ptr{SCIP_ROW},), - row, - ) +function SCIPselectIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, k, len) + ccall((:SCIPselectIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Cint, Cint), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, k, len) end -function SCIProwGetName(row) - ccall((:SCIProwGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_ROW},), row) +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{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, weights, capacity, len, medianpos) end -function SCIProwGetIndex(row) - ccall((:SCIProwGetIndex, libscip), Cint, (Ptr{SCIP_ROW},), row) +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 SCIProwGetAge(row) - ccall((:SCIProwGetAge, libscip), Cint, (Ptr{SCIP_ROW},), row) +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 SCIProwGetRank(row) - ccall((:SCIProwGetRank, libscip), Cint, (Ptr{SCIP_ROW},), row) +function SCIPselectDownPtr(ptrarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Cint), ptrarray, ptrcomp, k, len) end -function SCIProwIsIntegral(row) - ccall((:SCIProwIsIntegral, libscip), Cuint, (Ptr{SCIP_ROW},), row) +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 SCIProwIsLocal(row) - ccall((:SCIProwIsLocal, libscip), Cuint, (Ptr{SCIP_ROW},), row) +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 SCIProwIsModifiable(row) - ccall((:SCIProwIsModifiable, libscip), Cuint, (Ptr{SCIP_ROW},), row) +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 SCIProwIsRemovable(row) - ccall((:SCIProwIsRemovable, libscip), Cuint, (Ptr{SCIP_ROW},), row) +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 SCIProwGetOrigintype(row) - ccall( - (:SCIProwGetOrigintype, libscip), - SCIP_ROWORIGINTYPE, - (Ptr{SCIP_ROW},), - row, - ) +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 SCIProwGetOriginConshdlr(row) - ccall( - (:SCIProwGetOriginConshdlr, libscip), - Ptr{SCIP_CONSHDLR}, - (Ptr{SCIP_ROW},), - row, - ) +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 SCIProwGetOriginCons(row) - ccall( - (:SCIProwGetOriginCons, libscip), - Ptr{SCIP_CONS}, - (Ptr{SCIP_ROW},), - row, - ) +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 SCIProwGetOriginSepa(row) - ccall( - (:SCIProwGetOriginSepa, libscip), - Ptr{SCIP_SEPA}, - (Ptr{SCIP_ROW},), - row, - ) +function SCIPselectDownPtrBool(ptrarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, boolarray, ptrcomp, k, len) end -function SCIProwIsInGlobalCutpool(row) - ccall((:SCIProwIsInGlobalCutpool, libscip), Cuint, (Ptr{SCIP_ROW},), row) +function SCIPselectWeightedDownPtrBool(ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) end -function SCIProwGetLPPos(row) - ccall((:SCIProwGetLPPos, libscip), Cint, (Ptr{SCIP_ROW},), row) +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 SCIProwGetLPDepth(row) - ccall((:SCIProwGetLPDepth, libscip), Cint, (Ptr{SCIP_ROW},), row) +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 SCIProwIsInLP(row) - ccall((:SCIProwIsInLP, libscip), Cuint, (Ptr{SCIP_ROW},), row) +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 SCIProwGetActiveLPCount(row) - ccall((:SCIProwGetActiveLPCount, libscip), Clonglong, (Ptr{SCIP_ROW},), row) +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 SCIProwGetNLPsAfterCreation(row) - ccall( - (:SCIProwGetNLPsAfterCreation, libscip), - Clonglong, - (Ptr{SCIP_ROW},), - row, - ) +function SCIPselectDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, boolarray, ptrcomp, k, len) end -function SCIProwChgRank(row, rank) - ccall((:SCIProwChgRank, libscip), Cvoid, (Ptr{SCIP_ROW}, Cint), row, rank) +function SCIPselectWeightedDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) end -function SCIPmatrixGetColValPtr(matrix, col) - ccall( - (:SCIPmatrixGetColValPtr, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetColIdxPtr(matrix, col) - ccall( - (:SCIPmatrixGetColIdxPtr, libscip), - Ptr{Cint}, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetColNNonzs(matrix, col) - ccall( - (:SCIPmatrixGetColNNonzs, libscip), - Cint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetNColumns(matrix) - ccall((:SCIPmatrixGetNColumns, libscip), Cint, (Ptr{SCIP_MATRIX},), matrix) +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 SCIPmatrixGetColUb(matrix, col) - ccall( - (:SCIPmatrixGetColUb, libscip), - Cdouble, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetColLb(matrix, col) - ccall( - (:SCIPmatrixGetColLb, libscip), - Cdouble, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetColNUplocks(matrix, col) - ccall( - (:SCIPmatrixGetColNUplocks, libscip), - Cint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetColNDownlocks(matrix, col) - ccall( - (:SCIPmatrixGetColNDownlocks, libscip), - Cint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetVar(matrix, col) - ccall( - (:SCIPmatrixGetVar, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetColName(matrix, col) - ccall( - (:SCIPmatrixGetColName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixGetRowValPtr(matrix, row) - ccall( - (:SCIPmatrixGetRowValPtr, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +function SCIPselectDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) + ccall((:SCIPselectDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) end -function SCIPmatrixGetRowIdxPtr(matrix, row) - ccall( - (:SCIPmatrixGetRowIdxPtr, libscip), - Ptr{Cint}, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +function SCIPselectWeightedDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) end -function SCIPmatrixGetRowNNonzs(matrix, row) - ccall( - (:SCIPmatrixGetRowNNonzs, libscip), - Cint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +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 SCIPmatrixGetRowName(matrix, row) - ccall( - (:SCIPmatrixGetRowName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +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 SCIPmatrixGetNRows(matrix) - ccall((:SCIPmatrixGetNRows, libscip), Cint, (Ptr{SCIP_MATRIX},), matrix) +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 SCIPmatrixGetRowLhs(matrix, row) - ccall( - (:SCIPmatrixGetRowLhs, libscip), - Cdouble, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +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 SCIPmatrixGetRowRhs(matrix, row) - ccall( - (:SCIPmatrixGetRowRhs, libscip), - Cdouble, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +function SCIPselectDownReal(realarray, k, len) + ccall((:SCIPselectDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Cint), realarray, k, len) end -function SCIPmatrixIsRowRhsInfinity(matrix, row) - ccall( - (:SCIPmatrixIsRowRhsInfinity, libscip), - Cuint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +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 SCIPmatrixGetNNonzs(matrix) - ccall((:SCIPmatrixGetNNonzs, libscip), Cint, (Ptr{SCIP_MATRIX},), matrix) +function SCIPselectDownRealPtr(realarray, ptrarray, k, len) + ccall((:SCIPselectDownRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, ptrarray, k, len) end -function SCIPmatrixGetRowMinActivity(matrix, row) - ccall( - (:SCIPmatrixGetRowMinActivity, libscip), - Cdouble, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +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 SCIPmatrixGetRowMaxActivity(matrix, row) - ccall( - (:SCIPmatrixGetRowMaxActivity, libscip), - Cdouble, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +function SCIPselectDownRealInt(realarray, intarray, k, len) + ccall((:SCIPselectDownRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray, intarray, k, len) end -function SCIPmatrixGetRowNMinActNegInf(matrix, row) - ccall( - (:SCIPmatrixGetRowNMinActNegInf, libscip), - Cint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +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 SCIPmatrixGetRowNMinActPosInf(matrix, row) - ccall( - (:SCIPmatrixGetRowNMinActPosInf, libscip), - Cint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +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 SCIPmatrixGetRowNMaxActNegInf(matrix, row) - ccall( - (:SCIPmatrixGetRowNMaxActNegInf, libscip), - Cint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +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 SCIPmatrixGetRowNMaxActPosInf(matrix, row) - ccall( - (:SCIPmatrixGetRowNMaxActPosInf, libscip), - Cint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +function SCIPselectDownRealBoolPtr(realarray, boolarray, ptrarray, k, len) + ccall((:SCIPselectDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, boolarray, ptrarray, k, len) end -function SCIPmatrixGetCons(matrix, row) - ccall( - (:SCIPmatrixGetCons, libscip), - Ptr{SCIP_CONS}, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - row, - ) +function SCIPselectWeightedDownRealBoolPtr(realarray, boolarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, weights, capacity, len, medianpos) end -function SCIPmatrixUplockConflict(matrix, col) - ccall( - (:SCIPmatrixUplockConflict, libscip), - Cuint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) +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 SCIPmatrixDownlockConflict(matrix, col) - ccall( - (:SCIPmatrixDownlockConflict, libscip), - Cuint, - (Ptr{SCIP_MATRIX}, Cint), - matrix, - col, - ) -end - -function SCIPmatrixCreate( - scip, - matrixptr, - onlyifcomplete, - initialized, - complete, - infeasible, - naddconss, - ndelconss, - nchgcoefs, - nchgbds, - nfixedvars, -) - ccall( - (:SCIPmatrixCreate, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{Ptr{SCIP_MATRIX}}, - Cuint, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - ), - scip, - matrixptr, - onlyifcomplete, - initialized, - complete, - infeasible, - naddconss, - ndelconss, - nchgcoefs, - nchgbds, - nfixedvars, - ) +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 SCIPmatrixFree(scip, matrix) - ccall( - (:SCIPmatrixFree, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{SCIP_MATRIX}}), - scip, - matrix, - ) +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 SCIPmatrixPrintRow(scip, matrix, row) - ccall( - (:SCIPmatrixPrintRow, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Cint), - scip, - matrix, - row, - ) +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 SCIPmatrixGetParallelRows(scip, matrix, scale, pclass) - ccall( - (:SCIPmatrixGetParallelRows, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Ptr{Cdouble}, Ptr{Cint}), - scip, - matrix, - scale, - pclass, - ) +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 SCIPmatrixRemoveColumnBounds(scip, matrix, col) - ccall( - (:SCIPmatrixRemoveColumnBounds, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Cint), - scip, - matrix, - col, - ) +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 SCIPmatrixGetParallelCols(scip, matrix, scale, pclass, varineq) - ccall( - (:SCIPmatrixGetParallelCols, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}), - scip, - matrix, - scale, - pclass, - varineq, - ) -end - -function SCIPmessagehdlrCreate( - messagehdlr, - bufferedoutput, - filename, - quiet, - messagewarning, - messagedialog, - messageinfo, - messagehdlrfree, - messagehdlrdata, -) - ccall( - (:SCIPmessagehdlrCreate, libscip), - SCIP_RETCODE, - ( - Ptr{Ptr{SCIP_MESSAGEHDLR}}, - Cuint, - Ptr{Cchar}, - Cuint, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{SCIP_MESSAGEHDLRDATA}, - ), - messagehdlr, - bufferedoutput, - filename, - quiet, - messagewarning, - messagedialog, - messageinfo, - messagehdlrfree, - messagehdlrdata, - ) +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 SCIPmessagehdlrCapture(messagehdlr) - ccall( - (:SCIPmessagehdlrCapture, libscip), - Cvoid, - (Ptr{SCIP_MESSAGEHDLR},), - messagehdlr, - ) +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 SCIPmessagehdlrRelease(messagehdlr) - ccall( - (:SCIPmessagehdlrRelease, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_MESSAGEHDLR}},), - messagehdlr, - ) +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 SCIPmessagehdlrSetData(messagehdlr, messagehdlrdata) - ccall( - (:SCIPmessagehdlrSetData, libscip), - SCIP_RETCODE, - (Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_MESSAGEHDLRDATA}), - messagehdlr, - messagehdlrdata, - ) +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 SCIPmessagehdlrSetLogfile(messagehdlr, filename) - ccall( - (:SCIPmessagehdlrSetLogfile, libscip), - Cvoid, - (Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}), - messagehdlr, - filename, - ) +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 SCIPmessagehdlrSetQuiet(messagehdlr, quiet) - ccall( - (:SCIPmessagehdlrSetQuiet, libscip), - Cvoid, - (Ptr{SCIP_MESSAGEHDLR}, Cuint), - messagehdlr, - quiet, - ) +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 SCIPmessageSetErrorPrinting(errorPrinting, data) - ccall( - (:SCIPmessageSetErrorPrinting, libscip), - Cvoid, - (Ptr{Cvoid}, Ptr{Cvoid}), - errorPrinting, - data, - ) +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 SCIPmessageSetErrorPrintingDefault() - ccall((:SCIPmessageSetErrorPrintingDefault, libscip), Cvoid, ()) +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 SCIPmessagehdlrGetData(messagehdlr) - ccall( - (:SCIPmessagehdlrGetData, libscip), - Ptr{SCIP_MESSAGEHDLRDATA}, - (Ptr{SCIP_MESSAGEHDLR},), - messagehdlr, - ) +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 SCIPmessagehdlrGetLogfile(messagehdlr) - ccall( - (:SCIPmessagehdlrGetLogfile, libscip), - Ptr{Libc.FILE}, - (Ptr{SCIP_MESSAGEHDLR},), - messagehdlr, - ) +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 SCIPmessagehdlrIsQuiet(messagehdlr) - ccall( - (:SCIPmessagehdlrIsQuiet, libscip), - Cuint, - (Ptr{SCIP_MESSAGEHDLR},), - messagehdlr, - ) +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 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, - ) +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 SCIPerf(x) - ccall((:SCIPerf, libscip), Cdouble, (Cdouble,), x) +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 SCIPnormalGetCriticalValue(clevel) - ccall( - (:SCIPnormalGetCriticalValue, libscip), - Cdouble, - (SCIP_CONFIDENCELEVEL,), - clevel, - ) +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 SCIPnormalCDF(mean, variance, value) - ccall( - (:SCIPnormalCDF, libscip), - Cdouble, - (Cdouble, Cdouble, Cdouble), - mean, - variance, - value, - ) +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 SCIPregressionGetNObservations(regression) - ccall( - (:SCIPregressionGetNObservations, libscip), - Cint, - (Ptr{SCIP_REGRESSION},), - regression, - ) +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 SCIPregressionGetSlope(regression) - ccall( - (:SCIPregressionGetSlope, libscip), - Cdouble, - (Ptr{SCIP_REGRESSION},), - regression, - ) +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 SCIPregressionGetIntercept(regression) - ccall( - (:SCIPregressionGetIntercept, libscip), - Cdouble, - (Ptr{SCIP_REGRESSION},), - regression, - ) +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 SCIPregressionRemoveObservation(regression, x, y) - ccall( - (:SCIPregressionRemoveObservation, libscip), - Cvoid, - (Ptr{SCIP_REGRESSION}, Cdouble, Cdouble), - regression, - x, - y, - ) +function SCIPselectDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) + ccall((:SCIPselectDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) end -function SCIPregressionAddObservation(regression, x, y) - ccall( - (:SCIPregressionAddObservation, libscip), - Cvoid, - (Ptr{SCIP_REGRESSION}, Cdouble, Cdouble), - regression, - x, - y, - ) +function SCIPselectWeightedDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) end -function SCIPregressionReset(regression) - ccall( - (:SCIPregressionReset, libscip), - Cvoid, - (Ptr{SCIP_REGRESSION},), - regression, - ) +function SCIPselectDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, k, len) + ccall((:SCIPselectDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, k, len) end -function SCIPregressionCreate(regression) - ccall( - (:SCIPregressionCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_REGRESSION}},), - regression, - ) +function SCIPselectWeightedDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, weights, capacity, len, medianpos) end -function SCIPregressionFree(regression) - ccall( - (:SCIPregressionFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_REGRESSION}},), - regression, - ) +function SCIPselectDownInt(intarray, k, len) + ccall((:SCIPselectDownInt, libscip), Cvoid, (Ptr{Cint}, Cint, Cint), intarray, k, len) end -function SCIPgmlWriteNode(file, id, label, nodetype, fillcolor, bordercolor) - ccall( - (:SCIPgmlWriteNode, libscip), - Cvoid, - (Ptr{Libc.FILE}, Cuint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}), - file, - id, - label, - nodetype, - fillcolor, - bordercolor, - ) -end - -function SCIPgmlWriteNodeWeight( - file, - id, - label, - nodetype, - fillcolor, - bordercolor, - weight, -) - ccall( - (:SCIPgmlWriteNodeWeight, libscip), - Cvoid, - ( - Ptr{Libc.FILE}, - Cuint, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cchar}, - Ptr{Cchar}, - Cdouble, - ), - file, - id, - label, - nodetype, - fillcolor, - bordercolor, - weight, - ) +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 SCIPgmlWriteEdge(file, source, target, label, color) - ccall( - (:SCIPgmlWriteEdge, libscip), - Cvoid, - (Ptr{Libc.FILE}, Cuint, Cuint, Ptr{Cchar}, Ptr{Cchar}), - file, - source, - target, - label, - color, - ) +function SCIPselectDownIntInt(intarray1, intarray2, k, len) + ccall((:SCIPselectDownIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Cint), intarray1, intarray2, k, len) end -function SCIPgmlWriteArc(file, source, target, label, color) - ccall( - (:SCIPgmlWriteArc, libscip), - Cvoid, - (Ptr{Libc.FILE}, Cuint, Cuint, Ptr{Cchar}, Ptr{Cchar}), - file, - source, - target, - label, - color, - ) +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 SCIPgmlWriteOpening(file, directed) - ccall( - (:SCIPgmlWriteOpening, libscip), - Cvoid, - (Ptr{Libc.FILE}, Cuint), - file, - directed, - ) +function SCIPselectDownIntPtr(intarray, ptrarray, k, len) + ccall((:SCIPselectDownIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray, ptrarray, k, len) end -function SCIPgmlWriteClosing(file) - ccall((:SCIPgmlWriteClosing, libscip), Cvoid, (Ptr{Libc.FILE},), file) +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 SCIPsparseSolCreate(sparsesol, vars, nvars, cleared) - ccall( - (:SCIPsparseSolCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_SPARSESOL}}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint), - sparsesol, - vars, - nvars, - cleared, - ) +function SCIPselectDownIntReal(intarray, realarray, k, len) + ccall((:SCIPselectDownIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Cint), intarray, realarray, k, len) end -function SCIPsparseSolFree(sparsesol) - ccall( - (:SCIPsparseSolFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_SPARSESOL}},), - sparsesol, - ) +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 SCIPsparseSolGetVars(sparsesol) - ccall( - (:SCIPsparseSolGetVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_SPARSESOL},), - sparsesol, - ) +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 SCIPsparseSolGetNVars(sparsesol) - ccall( - (:SCIPsparseSolGetNVars, libscip), - Cint, - (Ptr{SCIP_SPARSESOL},), - sparsesol, - ) +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 SCIPsparseSolGetLbs(sparsesol) - ccall( - (:SCIPsparseSolGetLbs, libscip), - Ptr{Clonglong}, - (Ptr{SCIP_SPARSESOL},), - sparsesol, - ) +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 SCIPsparseSolGetUbs(sparsesol) - ccall( - (:SCIPsparseSolGetUbs, libscip), - Ptr{Clonglong}, - (Ptr{SCIP_SPARSESOL},), - sparsesol, - ) +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 SCIPsparseSolGetFirstSol(sparsesol, sol, nvars) - ccall( - (:SCIPsparseSolGetFirstSol, libscip), - Cvoid, - (Ptr{SCIP_SPARSESOL}, Ptr{Clonglong}, Cint), - sparsesol, - sol, - nvars, - ) +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 SCIPsparseSolGetNextSol(sparsesol, sol, nvars) - ccall( - (:SCIPsparseSolGetNextSol, libscip), - Cuint, - (Ptr{SCIP_SPARSESOL}, Ptr{Clonglong}, Cint), - sparsesol, - sol, - nvars, - ) +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 SCIPqueueCreate(queue, initsize, sizefac) - ccall( - (:SCIPqueueCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_QUEUE}}, Cint, Cdouble), - queue, - initsize, - sizefac, - ) +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 SCIPqueueFree(queue) - ccall((:SCIPqueueFree, libscip), Cvoid, (Ptr{Ptr{SCIP_QUEUE}},), queue) +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 SCIPqueueClear(queue) - ccall((:SCIPqueueClear, libscip), Cvoid, (Ptr{SCIP_QUEUE},), queue) +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 SCIPqueueInsert(queue, elem) - ccall( - (:SCIPqueueInsert, libscip), - SCIP_RETCODE, - (Ptr{SCIP_QUEUE}, Ptr{Cvoid}), - queue, - elem, - ) +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 SCIPqueueInsertUInt(queue, elem) - ccall( - (:SCIPqueueInsertUInt, libscip), - SCIP_RETCODE, - (Ptr{SCIP_QUEUE}, Cuint), - queue, - elem, - ) +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 SCIPqueueRemove(queue) - ccall((:SCIPqueueRemove, libscip), Ptr{Cvoid}, (Ptr{SCIP_QUEUE},), queue) +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 SCIPqueueRemoveUInt(queue) - ccall((:SCIPqueueRemoveUInt, libscip), Cuint, (Ptr{SCIP_QUEUE},), queue) +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 SCIPqueueFirst(queue) - ccall((:SCIPqueueFirst, libscip), Ptr{Cvoid}, (Ptr{SCIP_QUEUE},), queue) +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 SCIPqueueFirstUInt(queue) - ccall((:SCIPqueueFirstUInt, libscip), Cuint, (Ptr{SCIP_QUEUE},), queue) +function SCIPselectDownLong(longarray, k, len) + ccall((:SCIPselectDownLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Cint), longarray, k, len) end -function SCIPqueueIsEmpty(queue) - ccall((:SCIPqueueIsEmpty, libscip), Cuint, (Ptr{SCIP_QUEUE},), queue) +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 SCIPqueueNElems(queue) - ccall((:SCIPqueueNElems, libscip), Cint, (Ptr{SCIP_QUEUE},), queue) +function SCIPselectDownLongPtr(longarray, ptrarray, k, len) + ccall((:SCIPselectDownLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Cint), longarray, ptrarray, k, len) end -function SCIPpqueueCreate(pqueue, initsize, sizefac, ptrcomp, elemchgpos) - ccall( - (:SCIPpqueueCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_PQUEUE}}, Cint, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), - pqueue, - initsize, - sizefac, - ptrcomp, - elemchgpos, - ) +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 SCIPpqueueFree(pqueue) - ccall((:SCIPpqueueFree, libscip), Cvoid, (Ptr{Ptr{SCIP_PQUEUE}},), pqueue) +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 SCIPpqueueClear(pqueue) - ccall((:SCIPpqueueClear, libscip), Cvoid, (Ptr{SCIP_PQUEUE},), pqueue) +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 SCIPpqueueInsert(pqueue, elem) - ccall( - (:SCIPpqueueInsert, libscip), - SCIP_RETCODE, - (Ptr{SCIP_PQUEUE}, Ptr{Cvoid}), - pqueue, - elem, - ) +function SCIPselectDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, k, len) + ccall((:SCIPselectDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Cint), longarray, ptrarray, realarray, boolarray, k, len) end -function SCIPpqueueDelPos(pqueue, pos) - ccall( - (:SCIPpqueueDelPos, libscip), - Cvoid, - (Ptr{SCIP_PQUEUE}, Cint), - pqueue, - pos, - ) +function SCIPselectWeightedDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, weights, capacity, len, medianpos) end -function SCIPpqueueRemove(pqueue) - ccall((:SCIPpqueueRemove, libscip), Ptr{Cvoid}, (Ptr{SCIP_PQUEUE},), pqueue) +function SCIPselectDownLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, k, len) + ccall((:SCIPselectDownLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Cint), longarray, ptrarray, realarray, realarray2, boolarray, k, len) end -function SCIPpqueueFirst(pqueue) - ccall((:SCIPpqueueFirst, libscip), Ptr{Cvoid}, (Ptr{SCIP_PQUEUE},), pqueue) +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{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, weights, capacity, len, medianpos) end -function SCIPpqueueNElems(pqueue) - ccall((:SCIPpqueueNElems, libscip), Cint, (Ptr{SCIP_PQUEUE},), pqueue) +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{Cuint}, Cint, Cint), longarray, ptrarray, realarray, realarray2, intarray, boolarray, k, len) end -function SCIPpqueueElems(pqueue) - ccall( - (:SCIPpqueueElems, libscip), - Ptr{Ptr{Cvoid}}, - (Ptr{SCIP_PQUEUE},), - pqueue, - ) +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{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, weights, capacity, len, medianpos) end -function SCIPpqueueFind(pqueue, elem) - ccall( - (:SCIPpqueueFind, libscip), - Cint, - (Ptr{SCIP_PQUEUE}, Ptr{Cvoid}), - pqueue, - elem, - ) +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 SCIPrealHashCode(x) - ccall((:SCIPrealHashCode, libscip), UInt32, (Cdouble,), x) +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 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, - ) +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 SCIPhashtableFree(hashtable) - ccall( - (:SCIPhashtableFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_HASHTABLE}},), - hashtable, - ) +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 SCIPhashtableClear(hashtable) - ccall( - (:SCIPhashtableClear, libscip), - Cvoid, - (Ptr{SCIP_HASHTABLE},), - hashtable, - ) +function SCIPselectDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, k, len) + ccall((:SCIPselectDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Cint, Cint), longarray, ptrarray1, ptrarray2, boolarray, intarray, k, len) end -function SCIPhashtableInsert(hashtable, element) - ccall( - (:SCIPhashtableInsert, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), - hashtable, - element, - ) +function SCIPselectWeightedDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, weights, capacity, len, medianpos) end -function SCIPhashtableSafeInsert(hashtable, element) - ccall( - (:SCIPhashtableSafeInsert, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), - hashtable, - element, - ) +function SCIPselectDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, k, len) + ccall((:SCIPselectDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, k, len) end -function SCIPhashtableRetrieve(hashtable, key) - ccall( - (:SCIPhashtableRetrieve, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), - hashtable, - key, - ) +function SCIPselectWeightedDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) + ccall((:SCIPselectWeightedDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) end -function SCIPhashtableExists(hashtable, element) - ccall( - (:SCIPhashtableExists, libscip), - Cuint, - (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), - hashtable, - element, - ) +function SCIPselectDownIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, k, len) + ccall((:SCIPselectDownIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Cint, Cint), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, k, len) end -function SCIPhashtableRemove(hashtable, element) - ccall( - (:SCIPhashtableRemove, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), - hashtable, - element, - ) +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{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, weights, capacity, len, medianpos) end -function SCIPhashtableRemoveAll(hashtable) - ccall( - (:SCIPhashtableRemoveAll, libscip), - Cvoid, - (Ptr{SCIP_HASHTABLE},), - hashtable, - ) +function SCIPsortCompInt(elem1, elem2) + ccall((:SCIPsortCompInt, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) end -function SCIPhashtableGetNElements(hashtable) - ccall( - (:SCIPhashtableGetNElements, libscip), - Clonglong, - (Ptr{SCIP_HASHTABLE},), - hashtable, - ) +function SCIPsortArgsortInt(dataptr, ind1, ind2) + ccall((:SCIPsortArgsortInt, libscip), Cint, (Ptr{Cvoid}, Cint, Cint), dataptr, ind1, ind2) end -function SCIPhashtableGetNEntries(hashtable) - ccall( - (:SCIPhashtableGetNEntries, libscip), - Cint, - (Ptr{SCIP_HASHTABLE},), - hashtable, - ) +function SCIPsortArgsortPtr(dataptr, ind1, ind2) + ccall((:SCIPsortArgsortPtr, libscip), Cint, (Ptr{Cvoid}, Cint, Cint), dataptr, ind1, ind2) end -function SCIPhashtableGetEntry(hashtable, entryidx) - ccall( - (:SCIPhashtableGetEntry, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_HASHTABLE}, Cint), - hashtable, - entryidx, - ) +function SCIPsort(perm, indcomp, dataptr, len) + ccall((:SCIPsort, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), perm, indcomp, dataptr, len) end -function SCIPhashtableGetLoad(hashtable) - ccall( - (:SCIPhashtableGetLoad, libscip), - Cdouble, - (Ptr{SCIP_HASHTABLE},), - hashtable, - ) +function SCIPsortInd(indarray, indcomp, dataptr, len) + ccall((:SCIPsortInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), indarray, indcomp, dataptr, len) end -function SCIPhashtablePrintStatistics(hashtable, messagehdlr) - ccall( - (:SCIPhashtablePrintStatistics, libscip), - Cvoid, - (Ptr{SCIP_HASHTABLE}, Ptr{SCIP_MESSAGEHDLR}), - hashtable, - messagehdlr, - ) +function SCIPsortPtr(ptrarray, ptrcomp, len) + ccall((:SCIPsortPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), ptrarray, ptrcomp, len) end -function SCIPcalcMultihashSize(minsize) - ccall((:SCIPcalcMultihashSize, libscip), Cint, (Cint,), minsize) +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 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, - ) +function SCIPsortPtrReal(ptrarray, realarray, ptrcomp, len) + ccall((:SCIPsortPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), ptrarray, realarray, ptrcomp, len) end -function SCIPmultihashFree(multihash) - ccall( - (:SCIPmultihashFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_MULTIHASH}},), - multihash, - ) +function SCIPsortPtrInt(ptrarray, intarray, ptrcomp, len) + ccall((:SCIPsortPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, intarray, ptrcomp, len) end -function SCIPmultihashInsert(multihash, element) - ccall( - (:SCIPmultihashInsert, libscip), - SCIP_RETCODE, - (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), - multihash, - element, - ) +function SCIPsortPtrBool(ptrarray, boolarray, ptrcomp, len) + ccall((:SCIPsortPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, boolarray, ptrcomp, len) end -function SCIPmultihashSafeInsert(multihash, element) - ccall( - (:SCIPmultihashSafeInsert, libscip), - SCIP_RETCODE, - (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), - multihash, - element, - ) +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 SCIPmultihashRetrieve(multihash, key) - ccall( - (:SCIPmultihashRetrieve, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), - multihash, - key, - ) +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 SCIPmultihashRetrieveNext(multihash, multihashlist, key) - ccall( - (:SCIPmultihashRetrieveNext, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_MULTIHASH}, Ptr{Ptr{SCIP_MULTIHASHLIST}}, Ptr{Cvoid}), - multihash, - multihashlist, - key, - ) +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 SCIPmultihashExists(multihash, element) - ccall( - (:SCIPmultihashExists, libscip), - Cuint, - (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), - multihash, - element, - ) +function SCIPsortPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, len) + ccall((:SCIPsortPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, len) end -function SCIPmultihashRemove(multihash, element) - ccall( - (:SCIPmultihashRemove, libscip), - SCIP_RETCODE, - (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), - multihash, - element, - ) +function SCIPsortPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, len) + ccall((:SCIPsortPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, len) end -function SCIPmultihashRemoveAll(multihash) - ccall( - (:SCIPmultihashRemoveAll, libscip), - Cvoid, - (Ptr{SCIP_MULTIHASH},), - multihash, - ) +function SCIPsortPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) + ccall((:SCIPsortPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, realarray, boolarray, ptrcomp, len) end -function SCIPmultihashGetNElements(multihash) - ccall( - (:SCIPmultihashGetNElements, libscip), - Clonglong, - (Ptr{SCIP_MULTIHASH},), - multihash, - ) +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 SCIPmultihashGetLoad(multihash) - ccall( - (:SCIPmultihashGetLoad, libscip), - Cdouble, - (Ptr{SCIP_MULTIHASH},), - multihash, - ) +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 SCIPmultihashPrintStatistics(multihash, messagehdlr) - ccall( - (:SCIPmultihashPrintStatistics, libscip), - Cvoid, - (Ptr{SCIP_MULTIHASH}, Ptr{SCIP_MESSAGEHDLR}), - multihash, - messagehdlr, - ) +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 SCIPhashKeyEqString(userptr, key1, key2) - ccall( - (:SCIPhashKeyEqString, libscip), - Cuint, - (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), - userptr, - key1, - key2, - ) +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 SCIPhashKeyValString(userptr, key) - ccall( - (:SCIPhashKeyValString, libscip), - UInt64, - (Ptr{Cvoid}, Ptr{Cvoid}), - userptr, - key, - ) +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 SCIPhashGetKeyStandard(userptr, elem) - ccall( - (:SCIPhashGetKeyStandard, libscip), - Ptr{Cvoid}, - (Ptr{Cvoid}, Ptr{Cvoid}), - userptr, - elem, - ) +function SCIPsortPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, len) + ccall((:SCIPsortPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, len) end -function SCIPhashKeyEqPtr(userptr, key1, key2) - ccall( - (:SCIPhashKeyEqPtr, libscip), - Cuint, - (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), - userptr, - key1, - key2, - ) +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 SCIPhashKeyValPtr(userptr, key) - ccall( - (:SCIPhashKeyValPtr, libscip), - UInt64, - (Ptr{Cvoid}, Ptr{Cvoid}), - userptr, - key, - ) +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 SCIPhashmapCreate(hashmap, blkmem, mapsize) - ccall( - (:SCIPhashmapCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_HASHMAP}}, Ptr{BMS_BLKMEM}, Cint), - hashmap, - blkmem, - mapsize, - ) +function SCIPsortReal(realarray, len) + ccall((:SCIPsortReal, libscip), Cvoid, (Ptr{Cdouble}, Cint), realarray, len) end -function SCIPhashmapFree(hashmap) - ccall( - (:SCIPhashmapFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_HASHMAP}},), - hashmap, - ) +function SCIPsortRealPtr(realarray, ptrarray, len) + ccall((:SCIPsortRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray, ptrarray, len) end -function SCIPhashmapInsert(hashmap, origin, image) - ccall( - (:SCIPhashmapInsert, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Ptr{Cvoid}), - hashmap, - origin, - image, - ) +function SCIPsortRealInt(realarray, intarray, len) + ccall((:SCIPsortRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint), realarray, intarray, len) end -function SCIPhashmapInsertInt(hashmap, origin, image) - ccall( - (:SCIPhashmapInsertInt, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cint), - hashmap, - origin, - image, - ) +function SCIPsortRealIntInt(realarray, intarray1, intarray2, len) + ccall((:SCIPsortRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), realarray, intarray1, intarray2, len) end -function SCIPhashmapInsertReal(hashmap, origin, image) - ccall( - (:SCIPhashmapInsertReal, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cdouble), - hashmap, - origin, - image, - ) +function SCIPsortRealBoolPtr(realarray, boolarray, ptrarray, len) + ccall((:SCIPsortRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), realarray, boolarray, ptrarray, len) end -function SCIPhashmapGetImage(hashmap, origin) - ccall( - (:SCIPhashmapGetImage, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), - hashmap, - origin, - ) +function SCIPsortRealIntLong(realarray, intarray, longarray, len) + ccall((:SCIPsortRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint), realarray, intarray, longarray, len) end -function SCIPhashmapGetImageInt(hashmap, origin) - ccall( - (:SCIPhashmapGetImageInt, libscip), - Cint, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), - hashmap, - origin, - ) +function SCIPsortRealIntPtr(realarray, intarray, ptrarray, len) + ccall((:SCIPsortRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), realarray, intarray, ptrarray, len) end -function SCIPhashmapGetImageReal(hashmap, origin) - ccall( - (:SCIPhashmapGetImageReal, libscip), - Cdouble, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), - hashmap, - origin, - ) +function SCIPsortRealPtrPtr(realarray, ptrarray1, ptrarray2, len) + ccall((:SCIPsortRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), realarray, ptrarray1, ptrarray2, len) end -function SCIPhashmapSetImage(hashmap, origin, image) - ccall( - (:SCIPhashmapSetImage, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Ptr{Cvoid}), - hashmap, - origin, - image, - ) +function SCIPsortRealRealPtr(realarray1, realarray2, ptrarray, len) + ccall((:SCIPsortRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, ptrarray, len) end -function SCIPhashmapSetImageInt(hashmap, origin, image) - ccall( - (:SCIPhashmapSetImageInt, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cint), - hashmap, - origin, - image, - ) +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 SCIPhashmapSetImageReal(hashmap, origin, image) - ccall( - (:SCIPhashmapSetImageReal, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cdouble), - hashmap, - origin, - image, - ) +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 SCIPhashmapExists(hashmap, origin) - ccall( - (:SCIPhashmapExists, libscip), - Cuint, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), - hashmap, - origin, - ) +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 SCIPhashmapRemove(hashmap, origin) - ccall( - (:SCIPhashmapRemove, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), - hashmap, - origin, - ) +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 SCIPhashmapPrintStatistics(hashmap, messagehdlr) - ccall( - (:SCIPhashmapPrintStatistics, libscip), - Cvoid, - (Ptr{SCIP_HASHMAP}, Ptr{SCIP_MESSAGEHDLR}), - hashmap, - messagehdlr, - ) +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 SCIPhashmapIsEmpty(hashmap) - ccall((:SCIPhashmapIsEmpty, libscip), Cuint, (Ptr{SCIP_HASHMAP},), hashmap) +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 SCIPhashmapGetNElements(hashmap) - ccall( - (:SCIPhashmapGetNElements, libscip), - Cint, - (Ptr{SCIP_HASHMAP},), - hashmap, - ) +function SCIPsortRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, len) + ccall((:SCIPsortRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, len) end -function SCIPhashmapGetNEntries(hashmap) - ccall( - (:SCIPhashmapGetNEntries, libscip), - Cint, - (Ptr{SCIP_HASHMAP},), - hashmap, - ) +function SCIPsortRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, len) + ccall((:SCIPsortRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, len) end -function SCIPhashmapGetEntry(hashmap, entryidx) - ccall( - (:SCIPhashmapGetEntry, libscip), - Ptr{SCIP_HASHMAPENTRY}, - (Ptr{SCIP_HASHMAP}, Cint), - hashmap, - entryidx, - ) +function SCIPsortInt(intarray, len) + ccall((:SCIPsortInt, libscip), Cvoid, (Ptr{Cint}, Cint), intarray, len) end -function SCIPhashmapEntryGetOrigin(entry) - ccall( - (:SCIPhashmapEntryGetOrigin, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_HASHMAPENTRY},), - entry, - ) +function SCIPsortIntInt(intarray1, intarray2, len) + ccall((:SCIPsortIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint), intarray1, intarray2, len) end -function SCIPhashmapEntryGetImage(entry) - ccall( - (:SCIPhashmapEntryGetImage, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_HASHMAPENTRY},), - entry, - ) +function SCIPsortIntPtr(intarray, ptrarray, len) + ccall((:SCIPsortIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray, ptrarray, len) end -function SCIPhashmapEntryGetImageInt(entry) - ccall( - (:SCIPhashmapEntryGetImageInt, libscip), - Cint, - (Ptr{SCIP_HASHMAPENTRY},), - entry, - ) +function SCIPsortIntReal(intarray, realarray, len) + ccall((:SCIPsortIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint), intarray, realarray, len) end -function SCIPhashmapEntryGetImageReal(entry) - ccall( - (:SCIPhashmapEntryGetImageReal, libscip), - Cdouble, - (Ptr{SCIP_HASHMAPENTRY},), - entry, - ) +function SCIPsortIntIntInt(intarray1, intarray2, intarray3, len) + ccall((:SCIPsortIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint), intarray1, intarray2, intarray3, len) end -function SCIPhashmapEntrySetImage(entry, image) - ccall( - (:SCIPhashmapEntrySetImage, libscip), - Cvoid, - (Ptr{SCIP_HASHMAPENTRY}, Ptr{Cvoid}), - entry, - image, - ) +function SCIPsortIntIntLong(intarray1, intarray2, longarray, len) + ccall((:SCIPsortIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint), intarray1, intarray2, longarray, len) end -function SCIPhashmapEntrySetImageInt(entry, image) - ccall( - (:SCIPhashmapEntrySetImageInt, libscip), - Cvoid, - (Ptr{SCIP_HASHMAPENTRY}, Cint), - entry, - image, - ) +function SCIPsortIntRealLong(intarray, realarray, longarray, len) + ccall((:SCIPsortIntRealLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Cint), intarray, realarray, longarray, len) end -function SCIPhashmapEntrySetImageReal(entry, image) - ccall( - (:SCIPhashmapEntrySetImageReal, libscip), - Cvoid, - (Ptr{SCIP_HASHMAPENTRY}, Cdouble), - entry, - image, - ) +function SCIPsortIntIntPtr(intarray1, intarray2, ptrarray, len) + ccall((:SCIPsortIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray1, intarray2, ptrarray, len) end -function SCIPhashmapRemoveAll(hashmap) - ccall( - (:SCIPhashmapRemoveAll, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHMAP},), - hashmap, - ) +function SCIPsortIntIntReal(intarray1, intarray2, realarray, len) + ccall((:SCIPsortIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint), intarray1, intarray2, realarray, len) end -function SCIPhashsetCreate(hashset, blkmem, size) - ccall( - (:SCIPhashsetCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_HASHSET}}, Ptr{BMS_BLKMEM}, Cint), - hashset, - blkmem, - size, - ) +function SCIPsortIntPtrReal(intarray, ptrarray, realarray, len) + ccall((:SCIPsortIntPtrReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cint), intarray, ptrarray, realarray, len) end -function SCIPhashsetFree(hashset, blkmem) - ccall( - (:SCIPhashsetFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_HASHSET}}, Ptr{BMS_BLKMEM}), - hashset, - blkmem, - ) +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 SCIPhashsetInsert(hashset, blkmem, element) - ccall( - (:SCIPhashsetInsert, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHSET}, Ptr{BMS_BLKMEM}, Ptr{Cvoid}), - hashset, - blkmem, - element, - ) +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 SCIPhashsetExists(hashset, element) - ccall( - (:SCIPhashsetExists, libscip), - Cuint, - (Ptr{SCIP_HASHSET}, Ptr{Cvoid}), - hashset, - element, - ) +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 SCIPhashsetRemove(hashset, element) - ccall( - (:SCIPhashsetRemove, libscip), - SCIP_RETCODE, - (Ptr{SCIP_HASHSET}, Ptr{Cvoid}), - hashset, - element, - ) +function SCIPsortIntIntPtrPtr(intarray1, intarray2, ptrarray, ptrarray2, len) + ccall((:SCIPsortIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), intarray1, intarray2, ptrarray, ptrarray2, len) end -function SCIPhashsetPrintStatistics(hashset, messagehdlr) - ccall( - (:SCIPhashsetPrintStatistics, libscip), - Cvoid, - (Ptr{SCIP_HASHSET}, Ptr{SCIP_MESSAGEHDLR}), - hashset, - messagehdlr, - ) +function SCIPsortIntIntPtrPtrInterval(intarray1, intarray2, ptrarray, ptrarray2, intervalarray, len) + ccall((:SCIPsortIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Cint), intarray1, intarray2, ptrarray, ptrarray2, intervalarray, len) end -function SCIPhashsetIsEmpty(hashset) - ccall((:SCIPhashsetIsEmpty, libscip), Cuint, (Ptr{SCIP_HASHSET},), hashset) +function SCIPsortLong(longarray, len) + ccall((:SCIPsortLong, libscip), Cvoid, (Ptr{Clonglong}, Cint), longarray, len) end -function SCIPhashsetGetNElements(hashset) - ccall( - (:SCIPhashsetGetNElements, libscip), - Cint, - (Ptr{SCIP_HASHSET},), - hashset, - ) +function SCIPsortLongPtr(longarray, ptrarray, len) + ccall((:SCIPsortLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint), longarray, ptrarray, len) end -function SCIPhashsetGetNSlots(hashset) - ccall((:SCIPhashsetGetNSlots, libscip), Cint, (Ptr{SCIP_HASHSET},), hashset) +function SCIPsortLongPtrInt(longarray, ptrarray, intarray, len) + ccall((:SCIPsortLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), longarray, ptrarray, intarray, len) end -function SCIPhashsetGetSlots(hashset) - ccall( - (:SCIPhashsetGetSlots, libscip), - Ptr{Ptr{Cvoid}}, - (Ptr{SCIP_HASHSET},), - hashset, - ) +function SCIPsortLongPtrRealBool(longarray, ptrarray, realarray, boolarray, len) + ccall((:SCIPsortLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Cint), longarray, ptrarray, realarray, boolarray, len) end -function SCIPhashsetRemoveAll(hashset) - ccall( - (:SCIPhashsetRemoveAll, libscip), - Cvoid, - (Ptr{SCIP_HASHSET},), - hashset, - ) +function SCIPsortLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, len) + ccall((:SCIPsortLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Cint), longarray, ptrarray, realarray, realarray2, boolarray, len) 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, - ) +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{Cuint}, Cint), longarray, ptrarray, realarray, realarray2, intarray, boolarray, len) end -function SCIPactivityFree(activity) - ccall( - (:SCIPactivityFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_RESOURCEACTIVITY}},), - activity, - ) +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 SCIPactivityGetVar(activity) - ccall( - (:SCIPactivityGetVar, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_RESOURCEACTIVITY},), - activity, - ) +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 SCIPactivityGetDuration(activity) - ccall( - (:SCIPactivityGetDuration, libscip), - Cint, - (Ptr{SCIP_RESOURCEACTIVITY},), - activity, - ) +function SCIPsortLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, len) + ccall((:SCIPsortLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Cint), longarray, ptrarray1, ptrarray2, boolarray, intarray, len) end -function SCIPactivityGetDemand(activity) - ccall( - (:SCIPactivityGetDemand, libscip), - Cint, - (Ptr{SCIP_RESOURCEACTIVITY},), - activity, - ) +function SCIPsortPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, len) + ccall((:SCIPsortPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, len) end -function SCIPactivityGetEnergy(activity) - ccall( - (:SCIPactivityGetEnergy, libscip), - Cint, - (Ptr{SCIP_RESOURCEACTIVITY},), - activity, - ) +function SCIPsortIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, len) + ccall((:SCIPsortIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Cint), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, len) end -function SCIPprofileCreate(profile, capacity) - ccall( - (:SCIPprofileCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_PROFILE}}, Cint), - profile, - capacity, - ) +function SCIPsortDown(perm, indcomp, dataptr, len) + ccall((:SCIPsortDown, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), perm, indcomp, dataptr, len) end -function SCIPprofileFree(profile) - ccall( - (:SCIPprofileFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_PROFILE}},), - profile, - ) +function SCIPsortDownInd(indarray, indcomp, dataptr, len) + ccall((:SCIPsortDownInd, libscip), Cvoid, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), indarray, indcomp, dataptr, len) end -function SCIPprofilePrint(profile, messagehdlr, file) - ccall( - (:SCIPprofilePrint, libscip), - Cvoid, - (Ptr{SCIP_PROFILE}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), - profile, - messagehdlr, - file, - ) +function SCIPsortDownPtr(ptrarray, ptrcomp, len) + ccall((:SCIPsortDownPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), ptrarray, ptrcomp, len) end -function SCIPprofileGetCapacity(profile) - ccall( - (:SCIPprofileGetCapacity, libscip), - Cint, - (Ptr{SCIP_PROFILE},), - profile, - ) +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 SCIPprofileGetNTimepoints(profile) - ccall( - (:SCIPprofileGetNTimepoints, libscip), - Cint, - (Ptr{SCIP_PROFILE},), - profile, - ) +function SCIPsortDownPtrReal(ptrarray, realarray, ptrcomp, len) + ccall((:SCIPsortDownPtrReal, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), ptrarray, realarray, ptrcomp, len) end -function SCIPprofileGetTimepoints(profile) - ccall( - (:SCIPprofileGetTimepoints, libscip), - Ptr{Cint}, - (Ptr{SCIP_PROFILE},), - profile, - ) +function SCIPsortDownPtrInt(ptrarray, intarray, ptrcomp, len) + ccall((:SCIPsortDownPtrInt, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), ptrarray, intarray, ptrcomp, len) end -function SCIPprofileGetLoads(profile) - ccall( - (:SCIPprofileGetLoads, libscip), - Ptr{Cint}, - (Ptr{SCIP_PROFILE},), - profile, - ) +function SCIPsortDownPtrBool(ptrarray, boolarray, ptrcomp, len) + ccall((:SCIPsortDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, boolarray, ptrcomp, len) end -function SCIPprofileGetTime(profile, pos) - ccall( - (:SCIPprofileGetTime, libscip), - Cint, - (Ptr{SCIP_PROFILE}, Cint), - profile, - pos, - ) +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 SCIPprofileGetLoad(profile, pos) - ccall( - (:SCIPprofileGetLoad, libscip), - Cint, - (Ptr{SCIP_PROFILE}, Cint), - profile, - pos, - ) +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 SCIPprofileFindLeft(profile, timepoint, pos) - ccall( - (:SCIPprofileFindLeft, libscip), - Cuint, - (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{Cuint}), - 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{Cuint}), - 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{Cuint}), - profile, - lb, - ub, - duration, - height, - infeasible, - ) +function SCIPsortDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) + ccall((:SCIPsortDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, realarray, boolarray, ptrcomp, len) end -function SCIPdigraphResize(digraph, nnodes) - ccall( - (:SCIPdigraphResize, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIGRAPH}, Cint), - digraph, - nnodes, - ) +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 SCIPdigraphSetSizes(digraph, sizes) - ccall( - (:SCIPdigraphSetSizes, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIGRAPH}, Ptr{Cint}), - digraph, - sizes, - ) +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 SCIPdigraphFree(digraph) - ccall( - (:SCIPdigraphFree, libscip), - Cvoid, - (Ptr{Ptr{SCIP_DIGRAPH}},), - digraph, - ) +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 SCIPdigraphAddArc(digraph, startnode, endnode, data) - ccall( - (:SCIPdigraphAddArc, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIGRAPH}, Cint, Cint, Ptr{Cvoid}), - digraph, - startnode, - endnode, - data, - ) +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 SCIPdigraphAddArcSafe(digraph, startnode, endnode, data) - ccall( - (:SCIPdigraphAddArcSafe, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIGRAPH}, Cint, Cint, Ptr{Cvoid}), - digraph, - startnode, - endnode, - data, - ) +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 SCIPdigraphSetNSuccessors(digraph, node, nsuccessors) - ccall( - (:SCIPdigraphSetNSuccessors, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIGRAPH}, Cint, Cint), - digraph, - node, - nsuccessors, - ) +function SCIPsortDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, len) + ccall((:SCIPsortDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, len) end -function SCIPdigraphGetNNodes(digraph) - ccall((:SCIPdigraphGetNNodes, libscip), Cint, (Ptr{SCIP_DIGRAPH},), digraph) +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 SCIPdigraphGetNodeData(digraph, node) - ccall( - (:SCIPdigraphGetNodeData, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_DIGRAPH}, Cint), - digraph, - node, - ) +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 SCIPdigraphSetNodeData(digraph, dataptr, node) - ccall( - (:SCIPdigraphSetNodeData, libscip), - Cvoid, - (Ptr{SCIP_DIGRAPH}, Ptr{Cvoid}, Cint), - digraph, - dataptr, - node, - ) +function SCIPsortDownReal(realarray, len) + ccall((:SCIPsortDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cint), realarray, len) end -function SCIPdigraphGetNArcs(digraph) - ccall((:SCIPdigraphGetNArcs, libscip), Cint, (Ptr{SCIP_DIGRAPH},), digraph) +function SCIPsortDownRealPtr(realarray, ptrarray, len) + ccall((:SCIPsortDownRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray, ptrarray, len) end -function SCIPdigraphGetNSuccessors(digraph, node) - ccall( - (:SCIPdigraphGetNSuccessors, libscip), - Cint, - (Ptr{SCIP_DIGRAPH}, Cint), - digraph, - node, - ) +function SCIPsortDownRealInt(realarray, intarray, len) + ccall((:SCIPsortDownRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint), realarray, intarray, len) end -function SCIPdigraphGetSuccessors(digraph, node) - ccall( - (:SCIPdigraphGetSuccessors, libscip), - Ptr{Cint}, - (Ptr{SCIP_DIGRAPH}, Cint), - digraph, - node, - ) +function SCIPsortDownRealIntInt(realarray, intarray1, intarray2, len) + ccall((:SCIPsortDownRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), realarray, intarray1, intarray2, len) end -function SCIPdigraphGetSuccessorsData(digraph, node) - ccall( - (:SCIPdigraphGetSuccessorsData, libscip), - Ptr{Ptr{Cvoid}}, - (Ptr{SCIP_DIGRAPH}, Cint), - digraph, - node, - ) -end - -function SCIPdigraphGetArticulationPoints( - digraph, - articulations, - narticulations, -) - ccall( - (:SCIPdigraphGetArticulationPoints, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIGRAPH}, Ptr{Ptr{Cint}}, Ptr{Cint}), - digraph, - articulations, - narticulations, - ) -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, - ) +function SCIPsortDownRealBoolPtr(realarray, boolarray, ptrarray, len) + ccall((:SCIPsortDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), realarray, boolarray, ptrarray, len) end -function SCIPdigraphTopoSortComponents(digraph) - ccall( - (:SCIPdigraphTopoSortComponents, libscip), - SCIP_RETCODE, - (Ptr{SCIP_DIGRAPH},), - digraph, - ) +function SCIPsortDownRealIntLong(realarray, intarray, longarray, len) + ccall((:SCIPsortDownRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint), realarray, intarray, longarray, len) end -function SCIPdigraphGetNComponents(digraph) - ccall( - (:SCIPdigraphGetNComponents, libscip), - Cint, - (Ptr{SCIP_DIGRAPH},), - digraph, - ) +function SCIPsortDownRealIntPtr(realarray, intarray, ptrarray, len) + ccall((:SCIPsortDownRealIntPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), realarray, intarray, ptrarray, len) end -function SCIPdigraphGetComponent(digraph, compidx, nodes, nnodes) - ccall( - (:SCIPdigraphGetComponent, libscip), - Cvoid, - (Ptr{SCIP_DIGRAPH}, Cint, Ptr{Ptr{Cint}}, Ptr{Cint}), - digraph, - compidx, - nodes, - nnodes, - ) +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 SCIPdigraphFreeComponents(digraph) - ccall( - (:SCIPdigraphFreeComponents, libscip), - Cvoid, - (Ptr{SCIP_DIGRAPH},), - digraph, - ) +function SCIPsortDownRealRealInt(realarray1, realarray2, intarray, len) + ccall((:SCIPsortDownRealRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint), realarray1, realarray2, intarray, len) end -function SCIPdigraphPrint(digraph, messagehdlr, file) - ccall( - (:SCIPdigraphPrint, libscip), - Cvoid, - (Ptr{SCIP_DIGRAPH}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), - digraph, - messagehdlr, - file, - ) +function SCIPsortDownRealRealPtr(realarray1, realarray2, ptrarray, len) + ccall((:SCIPsortDownRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, ptrarray, len) end -function SCIPdigraphPrintGml(digraph, file) - ccall( - (:SCIPdigraphPrintGml, libscip), - Cvoid, - (Ptr{SCIP_DIGRAPH}, Ptr{Libc.FILE}), - digraph, - file, - ) +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 SCIPdigraphPrintComponents(digraph, messagehdlr, file) - ccall( - (:SCIPdigraphPrintComponents, libscip), - Cvoid, - (Ptr{SCIP_DIGRAPH}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), - digraph, - messagehdlr, - file, - ) +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 SCIPbtnodeCreate(tree, node, dataptr) - ccall( - (:SCIPbtnodeCreate, libscip), - SCIP_RETCODE, - (Ptr{SCIP_BT}, Ptr{Ptr{SCIP_BTNODE}}, Ptr{Cvoid}), - tree, - node, - dataptr, - ) +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 SCIPbtnodeFree(tree, node) - ccall( - (:SCIPbtnodeFree, libscip), - Cvoid, - (Ptr{SCIP_BT}, Ptr{Ptr{SCIP_BTNODE}}), - tree, - node, - ) +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 SCIPbtnodeGetData(node) - ccall((:SCIPbtnodeGetData, libscip), Ptr{Cvoid}, (Ptr{SCIP_BTNODE},), node) +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 SCIPbtnodeGetParent(node) - ccall( - (:SCIPbtnodeGetParent, libscip), - Ptr{SCIP_BTNODE}, - (Ptr{SCIP_BTNODE},), - node, - ) +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 SCIPbtnodeGetLeftchild(node) - ccall( - (:SCIPbtnodeGetLeftchild, libscip), - Ptr{SCIP_BTNODE}, - (Ptr{SCIP_BTNODE},), - node, - ) +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 SCIPbtnodeGetRightchild(node) - ccall( - (:SCIPbtnodeGetRightchild, libscip), - Ptr{SCIP_BTNODE}, - (Ptr{SCIP_BTNODE},), - node, - ) +function SCIPsortDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, len) + ccall((:SCIPsortDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, len) end -function SCIPbtnodeGetSibling(node) - ccall( - (:SCIPbtnodeGetSibling, libscip), - Ptr{SCIP_BTNODE}, - (Ptr{SCIP_BTNODE},), - node, - ) +function SCIPsortDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, len) + ccall((:SCIPsortDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, len) end -function SCIPbtnodeIsRoot(node) - ccall((:SCIPbtnodeIsRoot, libscip), Cuint, (Ptr{SCIP_BTNODE},), node) +function SCIPsortDownInt(intarray, len) + ccall((:SCIPsortDownInt, libscip), Cvoid, (Ptr{Cint}, Cint), intarray, len) end -function SCIPbtnodeIsLeaf(node) - ccall((:SCIPbtnodeIsLeaf, libscip), Cuint, (Ptr{SCIP_BTNODE},), node) +function SCIPsortDownIntInt(intarray1, intarray2, len) + ccall((:SCIPsortDownIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint), intarray1, intarray2, len) end -function SCIPbtnodeIsLeftchild(node) - ccall((:SCIPbtnodeIsLeftchild, libscip), Cuint, (Ptr{SCIP_BTNODE},), node) +function SCIPsortDownIntPtr(intarray, ptrarray, len) + ccall((:SCIPsortDownIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray, ptrarray, len) end -function SCIPbtnodeIsRightchild(node) - ccall((:SCIPbtnodeIsRightchild, libscip), Cuint, (Ptr{SCIP_BTNODE},), node) +function SCIPsortDownIntReal(intarray, realarray, len) + ccall((:SCIPsortDownIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint), intarray, realarray, len) end -function SCIPbtnodeSetData(node, dataptr) - ccall( - (:SCIPbtnodeSetData, libscip), - Cvoid, - (Ptr{SCIP_BTNODE}, Ptr{Cvoid}), - node, - dataptr, - ) +function SCIPsortDownIntIntInt(intarray1, intarray2, intarray3, len) + ccall((:SCIPsortDownIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint), intarray1, intarray2, intarray3, len) end -function SCIPbtnodeSetParent(node, parent) - ccall( - (:SCIPbtnodeSetParent, libscip), - Cvoid, - (Ptr{SCIP_BTNODE}, Ptr{SCIP_BTNODE}), - node, - parent, - ) +function SCIPsortDownIntIntLong(intarray1, intarray2, longarray, len) + ccall((:SCIPsortDownIntIntLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint), intarray1, intarray2, longarray, len) end -function SCIPbtnodeSetLeftchild(node, left) - ccall( - (:SCIPbtnodeSetLeftchild, libscip), - Cvoid, - (Ptr{SCIP_BTNODE}, Ptr{SCIP_BTNODE}), - node, - left, - ) +function SCIPsortDownIntIntPtr(intarray1, intarray2, ptrarray, len) + ccall((:SCIPsortDownIntIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), intarray1, intarray2, ptrarray, len) end -function SCIPbtnodeSetRightchild(node, right) - ccall( - (:SCIPbtnodeSetRightchild, libscip), - Cvoid, - (Ptr{SCIP_BTNODE}, Ptr{SCIP_BTNODE}), - node, - right, - ) +function SCIPsortDownIntIntReal(intarray1, intarray2, realarray, len) + ccall((:SCIPsortDownIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint), intarray1, intarray2, realarray, len) end -function SCIPbtCreate(tree, blkmem) - ccall( - (:SCIPbtCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_BT}}, Ptr{BMS_BLKMEM}), - tree, - blkmem, - ) +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 SCIPbtFree(tree) - ccall((:SCIPbtFree, libscip), Cvoid, (Ptr{Ptr{SCIP_BT}},), tree) +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 SCIPbtPrintGml(tree, file) - ccall( - (:SCIPbtPrintGml, libscip), - Cvoid, - (Ptr{SCIP_BT}, Ptr{Libc.FILE}), - tree, - file, - ) +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 SCIPbtIsEmpty(tree) - ccall((:SCIPbtIsEmpty, libscip), Cuint, (Ptr{SCIP_BT},), tree) +function SCIPsortDownLong(longarray, len) + ccall((:SCIPsortDownLong, libscip), Cvoid, (Ptr{Clonglong}, Cint), longarray, len) end -function SCIPbtGetRoot(tree) - ccall((:SCIPbtGetRoot, libscip), Ptr{SCIP_BTNODE}, (Ptr{SCIP_BT},), tree) +function SCIPsortDownLongPtr(longarray, ptrarray, len) + ccall((:SCIPsortDownLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint), longarray, ptrarray, len) end -function SCIPbtSetRoot(tree, root) - ccall( - (:SCIPbtSetRoot, libscip), - Cvoid, - (Ptr{SCIP_BT}, Ptr{SCIP_BTNODE}), - tree, - root, - ) +function SCIPsortDownLongPtrInt(longarray, ptrarray, intarray, len) + ccall((:SCIPsortDownLongPtrInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), longarray, ptrarray, intarray, len) end -function SCIPdisjointsetClear(djset) - ccall( - (:SCIPdisjointsetClear, libscip), - Cvoid, - (Ptr{SCIP_DISJOINTSET},), - djset, - ) +function SCIPsortDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, len) + ccall((:SCIPsortDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Cint), longarray, ptrarray, realarray, boolarray, len) end -function SCIPdisjointsetFind(djset, element) - ccall( - (:SCIPdisjointsetFind, libscip), - Cint, - (Ptr{SCIP_DISJOINTSET}, Cint), - djset, - element, - ) +function SCIPsortDownLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, len) + ccall((:SCIPsortDownLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Cint), longarray, ptrarray, realarray, realarray2, boolarray, len) end -function SCIPdisjointsetUnion(djset, p, q, forcerepofp) - ccall( - (:SCIPdisjointsetUnion, libscip), - Cvoid, - (Ptr{SCIP_DISJOINTSET}, Cint, Cint, Cuint), - djset, - p, - q, - forcerepofp, - ) +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{Cuint}, Cint), longarray, ptrarray, realarray, realarray2, intarray, boolarray, len) end -function SCIPdisjointsetGetComponentCount(djset) - ccall( - (:SCIPdisjointsetGetComponentCount, libscip), - Cint, - (Ptr{SCIP_DISJOINTSET},), - djset, - ) +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 SCIPdisjointsetGetSize(djset) - ccall( - (:SCIPdisjointsetGetSize, libscip), - Cint, - (Ptr{SCIP_DISJOINTSET},), - djset, - ) +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 SCIPcalcMachineEpsilon() - ccall((:SCIPcalcMachineEpsilon, libscip), Cdouble, ()) +function SCIPsortDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, len) + ccall((:SCIPsortDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Cint), longarray, ptrarray1, ptrarray2, boolarray, intarray, len) end -function SCIPnextafter(from, to) - ccall((:SCIPnextafter, libscip), Cdouble, (Cdouble, Cdouble), from, to) +function SCIPsortDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, len) + ccall((:SCIPsortDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, len) end -function SCIPcalcGreComDiv(val1, val2) - ccall( - (:SCIPcalcGreComDiv, libscip), - Clonglong, - (Clonglong, Clonglong), - val1, - val2, - ) +function SCIPsortDownIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, len) + ccall((:SCIPsortDownIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Cint), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, len) end -function SCIPcalcSmaComMul(val1, val2) - ccall( - (:SCIPcalcSmaComMul, libscip), - Clonglong, - (Clonglong, Clonglong), - val1, - val2, - ) +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 SCIPcalcBinomCoef(n, m) - ccall((:SCIPcalcBinomCoef, libscip), Clonglong, (Cint, Cint), n, m) +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 SCIPcalcFibHash(v) - ccall((:SCIPcalcFibHash, libscip), Cuint, (Cdouble,), v) +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 SCIPrealToRational( - val, - mindelta, - maxdelta, - maxdnom, - nominator, - denominator, -) - ccall( - (:SCIPrealToRational, libscip), - Cuint, - (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{Cuint}, - ), - vals, - nvals, - mindelta, - maxdelta, - maxdnom, - maxscale, - intscalar, - success, - ) -end - -function SCIPfindSimpleRational(lb, ub, maxdnom, nominator, denominator) - ccall( - (:SCIPfindSimpleRational, libscip), - Cuint, - (Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), - lb, - ub, - maxdnom, - nominator, - denominator, - ) +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 SCIPselectSimpleValue(lb, ub, maxdnom) - ccall( - (:SCIPselectSimpleValue, libscip), - Cdouble, - (Cdouble, Cdouble, Clonglong), - lb, - ub, - maxdnom, - ) +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 SCIPcalcRootNewton(_function, derivative, params, nparams, x, eps, k) - ccall( - (:SCIPcalcRootNewton, libscip), - Cdouble, - (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cdouble}, Cint, Cdouble, Cdouble, Cint), - _function, - derivative, - params, - nparams, - x, - eps, - k, - ) +function SCIPsortedvecInsertPtrBool(ptrarray, boolarray, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, boolarray, ptrcomp, keyval, field1val, len, pos) end -function SCIPrelDiff(val1, val2) - ccall((:SCIPrelDiff, libscip), Cdouble, (Cdouble, Cdouble), val1, val2) +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 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{Cuint}), - 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{Cuint}), - minrandval, - maxrandval, - seedp, - ) -end - -function SCIPgetRandomSubset(set, nelems, subset, nsubelems, randseed) - ccall( - (:SCIPgetRandomSubset, libscip), - SCIP_RETCODE, - (Ptr{Ptr{Cvoid}}, Cint, Ptr{Ptr{Cvoid}}, Cint, Cuint), - set, - nelems, - subset, - nsubelems, - randseed, - ) +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 SCIPswapInts(value1, value2) - ccall( - (:SCIPswapInts, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}), - value1, - value2, - ) +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 SCIPswapReals(value1, value2) - ccall( - (:SCIPswapReals, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cdouble}), - value1, - value2, - ) +function SCIPsortedvecInsertPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cdouble, Cuint, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) 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{Cuint}), - 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{Cuint}), - 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 SCIPcomputeArraysIntersectionInt( - array1, - narray1, - array2, - narray2, - intersectarray, - nintersectarray, -) - ccall( - (:SCIPcomputeArraysIntersectionInt, libscip), - Cvoid, - (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), - array1, - narray1, - array2, - narray2, - intersectarray, - nintersectarray, - ) -end - -function SCIPcomputeArraysIntersectionPtr( - array1, - narray1, - array2, - narray2, - ptrcomp, - intersectarray, - nintersectarray, -) - ccall( - (:SCIPcomputeArraysIntersectionPtr, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Cint, - Ptr{Ptr{Cvoid}}, - Cint, - Ptr{Cvoid}, - Ptr{Ptr{Cvoid}}, - Ptr{Cint}, - ), - array1, - narray1, - array2, - narray2, - ptrcomp, - 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 SCIPcomputeArraysSetminusInt( - array1, - narray1, - array2, - narray2, - setminusarray, - nsetminusarray, -) - ccall( - (:SCIPcomputeArraysSetminusInt, libscip), - Cvoid, - (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), - array1, - narray1, - array2, - narray2, - setminusarray, - nsetminusarray, - ) +function SCIPsortedvecInsertPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cdouble, Cint, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) end -function SCIPmemccpy(dest, src, stop, cnt) - ccall( - (:SCIPmemccpy, libscip), - Cint, - (Ptr{Cchar}, Ptr{Cchar}, Cchar, Cuint), - dest, - src, - stop, - cnt, - ) +function SCIPsortedvecInsertPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) end -function SCIPprintSysError(message) - ccall((:SCIPprintSysError, libscip), Cvoid, (Ptr{Cchar},), message) +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 SCIPstrtok(s, delim, ptrptr) - ccall( - (:SCIPstrtok, libscip), - Ptr{Cchar}, - (Ptr{Cchar}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), - s, - delim, - ptrptr, - ) +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 SCIPescapeString(t, bufsize, s) - ccall( - (:SCIPescapeString, libscip), - Cvoid, - (Ptr{Cchar}, Cint, Ptr{Cchar}), - t, - bufsize, - s, - ) +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 SCIPstrncpy(t, s, size) - ccall( - (:SCIPstrncpy, libscip), - Cint, - (Ptr{Cchar}, Ptr{Cchar}, Cint), - t, - s, - size, - ) +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 SCIPstrToIntValue(str, value, endptr) - ccall( - (:SCIPstrToIntValue, libscip), - Cuint, - (Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{Cchar}}), - str, - value, - endptr, - ) +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 SCIPstrToRealValue(str, value, endptr) - ccall( - (:SCIPstrToRealValue, libscip), - Cuint, - (Ptr{Cchar}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), - str, - value, - endptr, - ) +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{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) end -function SCIPstrCopySection(str, startchar, endchar, token, size, endptr) - ccall( - (:SCIPstrCopySection, libscip), - Cvoid, - (Ptr{Cchar}, Cchar, Cchar, Ptr{Cchar}, Cint, Ptr{Ptr{Cchar}}), - str, - startchar, - endchar, - token, - size, - endptr, - ) +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 SCIPstrAtStart(s, t, tlen) - ccall( - (:SCIPstrAtStart, libscip), - Cuint, - (Ptr{Cchar}, Ptr{Cchar}, Csize_t), - s, - t, - tlen, - ) +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 SCIPfileExists(filename) - ccall((:SCIPfileExists, libscip), Cuint, (Ptr{Cchar},), filename) +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 SCIPsplitFilename(filename, path, name, extension, compression) - ccall( - (:SCIPsplitFilename, libscip), - Cvoid, - ( - Ptr{Cchar}, - Ptr{Ptr{Cchar}}, - Ptr{Ptr{Cchar}}, - Ptr{Ptr{Cchar}}, - Ptr{Ptr{Cchar}}, - ), - filename, - path, - name, - extension, - compression, - ) +function SCIPsortedvecInsertRealBoolPtr(realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) end -function SCIPconsGetRhs(scip, cons, success) - ccall( - (:SCIPconsGetRhs, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), - scip, - cons, - success, - ) +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 SCIPconsGetLhs(scip, cons, success) - ccall( - (:SCIPconsGetLhs, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), - scip, - cons, - success, - ) +function SCIPsortedvecInsertReal(realarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertReal, libscip), Cvoid, (Ptr{Cdouble}, Cdouble, Ptr{Cint}, Ptr{Cint}), realarray, keyval, len, pos) end -function SCIPgetConsVals(scip, cons, vals, varssize, success) - ccall( - (:SCIPgetConsVals, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Cint, Ptr{Cuint}), - scip, - cons, - vals, - varssize, - success, - ) +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 SCIPconsGetDualfarkas(scip, cons, dualfarkas, success) - ccall( - (:SCIPconsGetDualfarkas, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), - scip, - cons, - dualfarkas, - success, - ) +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 SCIPconsGetDualsol(scip, cons, dualsol, success) - ccall( - (:SCIPconsGetDualsol, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), - scip, - cons, - dualsol, - success, - ) +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 SCIPconsGetRow(scip, cons) - ccall( - (:SCIPconsGetRow, libscip), - Ptr{SCIP_ROW}, - (Ptr{SCIP}, Ptr{SCIP_CONS}), - scip, - cons, - ) +function SCIPsortedvecInsertRealPtrPtr(realarray, ptrarray1, ptrarray2, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertRealPtrPtr, 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 SCIPconsAddCoef(scip, cons, var, val) - ccall( - (:SCIPconsAddCoef, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), - scip, - cons, - var, - val, - ) +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 SCIPcreateRowprep(scip, rowprep, sidetype, _local) - ccall( - (:SCIPcreateRowprep, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}, SCIP_SIDETYPE, Cuint), - scip, - rowprep, - sidetype, - _local, - ) +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 SCIPfreeRowprep(scip, rowprep) - ccall( - (:SCIPfreeRowprep, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}), - scip, - rowprep, - ) +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 SCIPcopyRowprep(scip, target, source) - ccall( - (:SCIPcopyRowprep, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}, Ptr{SCIP_ROWPREP}), - scip, - target, - source, - ) +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 SCIProwprepGetNVars(rowprep) - ccall((:SCIProwprepGetNVars, libscip), Cint, (Ptr{SCIP_ROWPREP},), rowprep) +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 SCIProwprepGetVars(rowprep) - ccall( - (:SCIProwprepGetVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_ROWPREP},), - rowprep, - ) +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 SCIProwprepGetCoefs(rowprep) - ccall( - (:SCIProwprepGetCoefs, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_ROWPREP},), - rowprep, - ) +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 SCIProwprepGetSide(rowprep) - ccall( - (:SCIProwprepGetSide, libscip), - Cdouble, - (Ptr{SCIP_ROWPREP},), - rowprep, - ) +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{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, keyval, field1val, field2val, field3val, field4val, len, pos) end -function SCIProwprepGetSidetype(rowprep) - ccall( - (:SCIProwprepGetSidetype, libscip), - SCIP_SIDETYPE, - (Ptr{SCIP_ROWPREP},), - rowprep, - ) +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{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) end -function SCIProwprepIsLocal(rowprep) - ccall((:SCIProwprepIsLocal, libscip), Cuint, (Ptr{SCIP_ROWPREP},), rowprep) +function SCIPsortedvecInsertInt(intarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), intarray, keyval, len, pos) end -function SCIProwprepGetName(rowprep) - ccall( - (:SCIProwprepGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_ROWPREP},), - rowprep, - ) +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 SCIProwprepGetNModifiedVars(rowprep) - ccall( - (:SCIProwprepGetNModifiedVars, libscip), - Cint, - (Ptr{SCIP_ROWPREP},), - rowprep, - ) +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 SCIProwprepGetModifiedVars(rowprep) - ccall( - (:SCIProwprepGetModifiedVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_ROWPREP},), - rowprep, - ) +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 SCIProwprepReset(rowprep) - ccall((:SCIProwprepReset, libscip), Cvoid, (Ptr{SCIP_ROWPREP},), rowprep) +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 SCIProwprepAddSide(rowprep, side) - ccall( - (:SCIProwprepAddSide, libscip), - Cvoid, - (Ptr{SCIP_ROWPREP}, Cdouble), - rowprep, - side, - ) +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 SCIProwprepAddConstant(rowprep, constant) - ccall( - (:SCIProwprepAddConstant, libscip), - Cvoid, - (Ptr{SCIP_ROWPREP}, Cdouble), - rowprep, - constant, - ) +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 SCIProwprepSetSidetype(rowprep, sidetype) - ccall( - (:SCIProwprepSetSidetype, libscip), - Cvoid, - (Ptr{SCIP_ROWPREP}, SCIP_SIDETYPE), - rowprep, - sidetype, - ) +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 SCIProwprepSetLocal(rowprep, islocal) - ccall( - (:SCIProwprepSetLocal, libscip), - Cvoid, - (Ptr{SCIP_ROWPREP}, Cuint), - rowprep, - islocal, - ) +function SCIPsortedvecInsertIntIntPtrPtr(intarray1, intarray2, ptrarray1, ptrarray2, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, keyval, field1val, field2val, field3val, len, pos) end -function SCIProwprepRecordModifications(rowprep) - ccall( - (:SCIProwprepRecordModifications, libscip), - Cvoid, - (Ptr{SCIP_ROWPREP},), - rowprep, - ) +function SCIPsortedvecInsertIntIntPtrPtrInterval(intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, keyval, field1val, field2val, field3val, field4val, len, pos) + ccall((:SCIPsortedvecInsertIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, SCIP_INTERVAL, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, keyval, field1val, field2val, field3val, field4val, len, pos) end -function SCIPprintRowprep(scip, rowprep, file) - ccall( - (:SCIPprintRowprep, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{Libc.FILE}), - scip, - rowprep, - file, - ) +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 SCIPprintRowprepSol(scip, rowprep, sol, file) - ccall( - (:SCIPprintRowprepSol, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), - scip, - rowprep, - sol, - file, - ) +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 SCIPensureRowprepSize(scip, rowprep, size) - ccall( - (:SCIPensureRowprepSize, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cint), - scip, - rowprep, - size, - ) +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 SCIPaddRowprepTerm(scip, rowprep, var, coef) - ccall( - (:SCIPaddRowprepTerm, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_VAR}, Cdouble), - scip, - rowprep, - var, - coef, - ) +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 SCIPaddRowprepTerms(scip, rowprep, nvars, vars, coefs) - ccall( - (:SCIPaddRowprepTerms, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), - scip, - rowprep, - nvars, - vars, - coefs, - ) +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 SCIPgetRowprepViolation(scip, rowprep, sol, reliable) - ccall( - (:SCIPgetRowprepViolation, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Ptr{Cuint}), - scip, - rowprep, - sol, - reliable, - ) +function SCIPsortedvecInsertLong(longarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertLong, libscip), Cvoid, (Ptr{Clonglong}, Clonglong, Ptr{Cint}, Ptr{Cint}), longarray, keyval, len, pos) end -function SCIPisRowprepViolationReliable(scip, rowprep, sol) - ccall( - (:SCIPisRowprepViolationReliable, libscip), - Cuint, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}), - scip, - rowprep, - sol, - ) +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 SCIPmergeRowprepTerms(scip, rowprep) - ccall( - (:SCIPmergeRowprepTerms, libscip), - Cvoid, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}), - scip, - rowprep, - ) +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 SCIPcleanupRowprep(scip, rowprep, sol, minviol, viol, success) - ccall( - (:SCIPcleanupRowprep, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP}, - Ptr{SCIP_ROWPREP}, - Ptr{SCIP_SOL}, - Cdouble, - Ptr{Cdouble}, - Ptr{Cuint}, - ), - scip, - rowprep, - sol, - minviol, - viol, - success, - ) +function SCIPsortedvecInsertLongPtrRealBool(longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) end -function SCIPcleanupRowprep2(scip, rowprep, sol, maxcoefbound, success) - ccall( - (:SCIPcleanupRowprep2, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Cdouble, Ptr{Cuint}), - scip, - rowprep, - sol, - maxcoefbound, - success, - ) +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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, keyval, field1val, field2val, field3val, field4val, len, pos) end -function SCIPscaleupRowprep(scip, rowprep, minscaleup, success) - ccall( - (:SCIPscaleupRowprep, libscip), - Cdouble, - (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cdouble, Ptr{Cuint}), - scip, - rowprep, - minscaleup, - success, - ) +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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cint, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) end -function SCIPscaleRowprep(rowprep, factor) - ccall( - (:SCIPscaleRowprep, libscip), - Cint, - (Ptr{SCIP_ROWPREP}, Cdouble), - rowprep, - factor, - ) +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 SCIPgetRowprepRowConshdlr(scip, row, rowprep, conshdlr) - ccall( - (:SCIPgetRowprepRowConshdlr, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_CONSHDLR}), - scip, - row, - rowprep, - conshdlr, - ) +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 SCIPgetRowprepRowCons(scip, row, rowprep, cons) - ccall( - (:SCIPgetRowprepRowCons, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_CONS}), - scip, - row, - rowprep, - cons, - ) +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{Cuint}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, Cuint, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, keyval, field1val, field2val, field3val, field4val, len, pos) end -function SCIPgetRowprepRowSepa(scip, row, rowprep, sepa) - ccall( - (:SCIPgetRowprepRowSepa, libscip), - SCIP_RETCODE, - (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SEPA}), - scip, - row, - rowprep, - sepa, - ) +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{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) end -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, - ) +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{Cuint}, Ptr{Cuint}, Cint, Ptr{Cvoid}, Cint, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) 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, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 SCIPselectPtrBool(ptrarray, boolarray, ptrcomp, k, len) - ccall( - (:SCIPselectPtrBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, 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{Cuint}, - Ptr{Cvoid}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - ptrarray, - boolarray, - ptrcomp, - weights, - capacity, - len, - medianpos, - ) +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 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, - ) +function SCIPsortedvecInsertDownPtrBool(ptrarray, boolarray, ptrcomp, keyval, field1val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, boolarray, ptrcomp, keyval, field1val, len, pos) 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 SCIPselectPtrRealRealBoolBool( - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - k, - len, -) - ccall( - (:SCIPselectPtrRealRealBoolBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Cint, - Cint, - ), - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - k, - len, - ) -end - -function SCIPselectPtrRealRealIntBool( - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - k, - len, -) - ccall( - (:SCIPselectPtrRealRealIntBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Cint, - Cint, - ), - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - 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 SCIPselectWeightedPtrRealRealBoolBool( - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - weights, - capacity, - len, - medianpos, -) - ccall( - (:SCIPselectWeightedPtrRealRealBoolBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - weights, - capacity, - len, - medianpos, - ) -end - -function SCIPselectWeightedPtrRealRealIntBool( - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - weights, - capacity, - len, - medianpos, -) - ccall( - (:SCIPselectWeightedPtrRealRealIntBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - weights, - capacity, - len, - medianpos, - ) +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 SCIPselectPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, k, len) - ccall( - (:SCIPselectPtrRealBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, - 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, - ) +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 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, - ) +function SCIPsortedvecInsertDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) 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{Cuint}, - 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{Cuint}, - 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, - ) +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 SCIPselectReal(realarray, k, len) - ccall( - (:SCIPselectReal, libscip), - Cvoid, - (Ptr{Cdouble}, Cint, Cint), - realarray, - k, - len, - ) +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 SCIPselectWeightedReal(realarray, weights, capacity, len, medianpos) - ccall( - (:SCIPselectWeightedReal, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), - realarray, - weights, - capacity, - len, - medianpos, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, len, pos) end -function SCIPselectRealBoolPtr(realarray, boolarray, ptrarray, k, len) - ccall( - (:SCIPselectRealBoolPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - realarray, - boolarray, - ptrarray, - weights, - capacity, - len, - medianpos, - ) +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 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, - ) +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 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, - ) +function SCIPsortedvecInsertDownReal(realarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cdouble, Ptr{Cint}, Ptr{Cint}), realarray, keyval, len, pos) 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - realarray1, - realarray2, - realarray3, - boolarray1, - boolarray2, - ptrarray, - weights, - capacity, - len, - medianpos, - ) +function SCIPsortedvecInsertDownRealBoolPtr(realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) + ccall((:SCIPsortedvecInsertDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) end -function SCIPselectInt(intarray, k, len) - ccall( - (:SCIPselectInt, libscip), - Cvoid, - (Ptr{Cint}, Cint, Cint), - intarray, - k, - len, - ) +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 SCIPselectWeightedInt(intarray, weights, capacity, len, medianpos) - ccall( - (:SCIPselectWeightedInt, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), - intarray, - weights, - capacity, - len, - medianpos, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 SCIPselectLong(longarray, k, len) - ccall( - (:SCIPselectLong, libscip), - Cvoid, - (Ptr{Clonglong}, Cint, Cint), - longarray, - k, - len, - ) +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 SCIPselectWeightedLong(longarray, weights, capacity, len, medianpos) - ccall( - (:SCIPselectWeightedLong, libscip), - Cvoid, - (Ptr{Clonglong}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), - longarray, - weights, - capacity, - len, - medianpos, - ) +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 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, - ) +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 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{Cuint}, 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - intarray1, - ptrarray, - intarray2, - intarray3, - boolarray1, - boolarray2, - weights, - capacity, - len, - medianpos, - ) +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 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, - ) +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{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, keyval, field1val, field2val, field3val, field4val, len, pos) 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, - ) +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{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) 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, - ) +function SCIPsortedvecInsertDownInt(intarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertDownInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), intarray, keyval, len, pos) 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, - ) +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 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, - ) +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 SCIPselectDownPtrBool(ptrarray, boolarray, ptrcomp, k, len) - ccall( - (:SCIPselectDownPtrBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, 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{Cuint}, - 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{Cuint}, 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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, - ) +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 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, - ) +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 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, - ) +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 SCIPselectDownRealInt(realarray, intarray, k, len) - ccall( - (:SCIPselectDownRealInt, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), - realarray, - intarray, - k, - len, - ) +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 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, - ) +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 SCIPselectDownRealBoolPtr(realarray, boolarray, ptrarray, k, len) - ccall( - (:SCIPselectDownRealBoolPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - realarray, - boolarray, - ptrarray, - weights, - capacity, - len, - medianpos, - ) +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 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, - ) +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 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, - ) +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 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, - ) +function SCIPsortedvecInsertDownLong(longarray, keyval, len, pos) + ccall((:SCIPsortedvecInsertDownLong, libscip), Cvoid, (Ptr{Clonglong}, Clonglong, Ptr{Cint}, Ptr{Cint}), longarray, keyval, len, pos) 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, - ) +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 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - realarray1, - realarray2, - realarray3, - boolarray1, - boolarray2, - ptrarray, - weights, - capacity, - len, - medianpos, - ) +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 SCIPselectDownInt(intarray, k, len) - ccall( - (:SCIPselectDownInt, libscip), - Cvoid, - (Ptr{Cint}, Cint, Cint), - intarray, - k, - len, - ) +function SCIPsortedvecInsertDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) + ccall((:SCIPsortedvecInsertDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) 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, - ) +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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, keyval, field1val, field2val, field3val, field4val, len, pos) 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, - ) +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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cint, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) 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, - ) +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 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, - ) +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 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, - ) +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{Cuint}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, Cuint, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, keyval, field1val, field2val, field3val, field4val, len, pos) 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, - ) +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{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) 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, - ) +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{Cuint}, Ptr{Cuint}, Cint, Ptr{Cvoid}, Cint, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) 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, - ) +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 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, - ) +function SCIPsortedvecDelPosPtr(ptrarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, pos, len) 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, - ) +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 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{Cuint}, 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Cdouble}, - Cdouble, - Cint, - Ptr{Cint}, - ), - intarray1, - ptrarray, - intarray2, - intarray3, - boolarray1, - boolarray2, - weights, - capacity, - len, - medianpos, - ) +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 SCIPsortCompInt(elem1, elem2) - ccall( - (:SCIPsortCompInt, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) +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 SCIPsort(perm, indcomp, dataptr, len) - ccall( - (:SCIPsort, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), - perm, - indcomp, - dataptr, - len, - ) +function SCIPsortedvecDelPosPtrBool(ptrarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, pos, len) end -function SCIPsortInd(indarray, indcomp, dataptr, len) - ccall( - (:SCIPsortInd, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), - indarray, - indcomp, - dataptr, - len, - ) +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 SCIPsortPtr(ptrarray, ptrcomp, len) - ccall( - (:SCIPsortPtr, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), - ptrarray, - ptrcomp, - len, - ) +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 SCIPsortPtrPtr(ptrarray1, ptrarray2, ptrcomp, len) - ccall( - (:SCIPsortPtrPtr, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), - ptrarray1, - ptrarray2, - ptrcomp, - len, - ) +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 SCIPsortPtrReal(ptrarray, realarray, ptrcomp, len) - ccall( - (:SCIPsortPtrReal, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), - ptrarray, - realarray, - ptrcomp, - len, - ) +function SCIPsortedvecDelPosPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, pos, len) end -function SCIPsortPtrInt(ptrarray, intarray, ptrcomp, len) - ccall( - (:SCIPsortPtrInt, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), - ptrarray, - intarray, - ptrcomp, - len, - ) +function SCIPsortedvecDelPosPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, pos, len) end -function SCIPsortPtrBool(ptrarray, boolarray, ptrcomp, len) - ccall( - (:SCIPsortPtrBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint), - ptrarray, - boolarray, - ptrcomp, - len, - ) +function SCIPsortedvecDelPosPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, pos, 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, - ) +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 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 SCIPsortPtrRealRealBoolBool( - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - len, -) - ccall( - (:SCIPsortPtrRealRealBoolBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Cint, - ), - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - len, - ) -end - -function SCIPsortPtrRealRealIntBool( - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - len, -) - ccall( - (:SCIPsortPtrRealRealIntBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Cint, - ), - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - len, - ) +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 SCIPsortPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) - ccall( - (:SCIPsortPtrRealBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, 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, - ) +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 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, - ) +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 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{Cuint}, - 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, - ) +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 SCIPsortReal(realarray, len) - ccall((:SCIPsortReal, libscip), Cvoid, (Ptr{Cdouble}, Cint), realarray, len) +function SCIPsortedvecDelPosPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) end -function SCIPsortRealPtr(realarray, ptrarray, len) - ccall( - (:SCIPsortRealPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), - realarray, - ptrarray, - len, - ) +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 SCIPsortRealInt(realarray, intarray, len) - ccall( - (:SCIPsortRealInt, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Cint), - realarray, - intarray, - len, - ) +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 SCIPsortRealIntInt(realarray, intarray1, intarray2, len) - ccall( - (:SCIPsortRealIntInt, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), - realarray, - intarray1, - intarray2, - len, - ) +function SCIPsortedvecDelPosRealBoolPtr(realarray, boolarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, pos, len) end -function SCIPsortRealBoolPtr(realarray, boolarray, ptrarray, len) - ccall( - (:SCIPsortRealBoolPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), - realarray, - boolarray, - ptrarray, - len, - ) +function SCIPsortedvecDelPosRealPtr(realarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, ptrarray, pos, len) end -function SCIPsortRealIntLong(realarray, intarray, longarray, len) - ccall( - (:SCIPsortRealIntLong, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint), - realarray, - intarray, - longarray, - len, - ) +function SCIPsortedvecDelPosReal(realarray, pos, len) + ccall((:SCIPsortedvecDelPosReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Ptr{Cint}), realarray, pos, len) end -function SCIPsortRealIntPtr(realarray, intarray, ptrarray, len) - ccall( - (:SCIPsortRealIntPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), - realarray, - intarray, - ptrarray, - len, - ) +function SCIPsortedvecDelPosRealInt(realarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, intarray, pos, len) end -function SCIPsortRealRealPtr(realarray1, realarray2, ptrarray, len) - ccall( - (:SCIPsortRealRealPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), - realarray1, - realarray2, - ptrarray, - len, - ) +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 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Ptr{Cvoid}}, - Cint, - ), - realarray1, - realarray2, - realarray3, - boolarray1, - boolarray2, - ptrarray, - len, - ) +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 SCIPsortInt(intarray, len) - ccall((:SCIPsortInt, libscip), Cvoid, (Ptr{Cint}, Cint), intarray, len) +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 SCIPsortIntInt(intarray1, intarray2, len) - ccall( - (:SCIPsortIntInt, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Cint), - intarray1, - intarray2, - len, - ) +function SCIPsortedvecDelPosRealPtrPtr(realarray, ptrarray1, ptrarray2, pos, len) + ccall((:SCIPsortedvecDelPosRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, pos, len) end -function SCIPsortIntPtr(intarray, ptrarray, len) - ccall( - (:SCIPsortIntPtr, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), - intarray, - ptrarray, - len, - ) +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 SCIPsortIntReal(intarray, realarray, len) - ccall( - (:SCIPsortIntReal, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cdouble}, Cint), - intarray, - realarray, - len, - ) +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 SCIPsortIntIntInt(intarray1, intarray2, intarray3, len) - ccall( - (:SCIPsortIntIntInt, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint), - intarray1, - intarray2, - intarray3, - len, - ) +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 SCIPsortIntIntLong(intarray1, intarray2, longarray, len) - ccall( - (:SCIPsortIntIntLong, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint), - intarray1, - intarray2, - longarray, - len, - ) +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 SCIPsortIntRealLong(intarray, realarray, longarray, len) - ccall( - (:SCIPsortIntRealLong, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Cint), - intarray, - realarray, - longarray, - len, - ) +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 SCIPsortIntIntPtr(intarray1, intarray2, ptrarray, len) - ccall( - (:SCIPsortIntIntPtr, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), - intarray1, - intarray2, - ptrarray, - len, - ) +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 SCIPsortIntIntReal(intarray1, intarray2, realarray, len) - ccall( - (:SCIPsortIntIntReal, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint), - intarray1, - intarray2, - realarray, - len, - ) +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 SCIPsortIntPtrReal(intarray, ptrarray, realarray, len) - ccall( - (:SCIPsortIntPtrReal, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cint), - intarray, - ptrarray, - realarray, - len, - ) +function SCIPsortedvecDelPosRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, pos, 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, - ) +function SCIPsortedvecDelPosRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, 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, - ) +function SCIPsortedvecDelPosInt(intarray, pos, len) + ccall((:SCIPsortedvecDelPosInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}), intarray, pos, 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, - ) +function SCIPsortedvecDelPosIntInt(intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), intarray1, intarray2, pos, len) end -function SCIPsortLong(longarray, len) - ccall( - (:SCIPsortLong, libscip), - Cvoid, - (Ptr{Clonglong}, Cint), - longarray, - len, - ) +function SCIPsortedvecDelPosIntReal(intarray, realarray, pos, len) + ccall((:SCIPsortedvecDelPosIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray, realarray, pos, len) end -function SCIPsortLongPtr(longarray, ptrarray, len) - ccall( - (:SCIPsortLongPtr, libscip), - Cvoid, - (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint), - longarray, - ptrarray, - len, - ) +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 SCIPsortLongPtrInt(longarray, ptrarray, intarray, len) - ccall( - (:SCIPsortLongPtrInt, libscip), - Cvoid, - (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), - longarray, - ptrarray, - intarray, - len, - ) +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 SCIPsortLongPtrRealBool(longarray, ptrarray, realarray, boolarray, len) - ccall( - (:SCIPsortLongPtrRealBool, libscip), - Cvoid, - (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, - 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{Cuint}, - Cint, - ), - longarray, - ptrarray, - realarray, - realarray2, - intarray, - boolarray, - len, - ) +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 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Cint, - ), - intarray1, - ptrarray, - intarray2, - intarray3, - boolarray1, - boolarray2, - len, - ) +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 SCIPsortDown(perm, indcomp, dataptr, len) - ccall( - (:SCIPsortDown, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), - perm, - indcomp, - dataptr, - len, - ) +function SCIPsortedvecDelPosIntIntPtrPtr(intarray1, intarray2, ptrarray1, ptrarray2, pos, len) + ccall((:SCIPsortedvecDelPosIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, pos, len) end -function SCIPsortDownInd(indarray, indcomp, dataptr, len) - ccall( - (:SCIPsortDownInd, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), - indarray, - indcomp, - dataptr, - len, - ) +function SCIPsortedvecDelPosIntIntPtrPtrInterval(intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, pos, len) + ccall((:SCIPsortedvecDelPosIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, pos, len) end -function SCIPsortDownPtr(ptrarray, ptrcomp, len) - ccall( - (:SCIPsortDownPtr, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), - ptrarray, - ptrcomp, - len, - ) +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 SCIPsortDownPtrPtr(ptrarray1, ptrarray2, ptrcomp, len) - ccall( - (:SCIPsortDownPtrPtr, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), - ptrarray1, - ptrarray2, - ptrcomp, - len, - ) +function SCIPsortedvecDelPosIntPtr(intarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray, ptrarray, pos, len) end -function SCIPsortDownPtrReal(ptrarray, realarray, ptrcomp, len) - ccall( - (:SCIPsortDownPtrReal, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), - ptrarray, - realarray, - ptrcomp, - len, - ) +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 SCIPsortDownPtrInt(ptrarray, intarray, ptrcomp, len) - ccall( - (:SCIPsortDownPtrInt, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), - ptrarray, - intarray, - ptrcomp, - len, - ) +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 SCIPsortDownPtrBool(ptrarray, boolarray, ptrcomp, len) - ccall( - (:SCIPsortDownPtrBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint), - ptrarray, - boolarray, - ptrcomp, - len, - ) +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 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, - ) +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 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, - ) +function SCIPsortedvecDelPosLong(longarray, pos, len) + ccall((:SCIPsortedvecDelPosLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Ptr{Cint}), longarray, pos, len) end -function SCIPsortDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) - ccall( - (:SCIPsortDownPtrRealBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint), - ptrarray, - realarray, - boolarray, - ptrcomp, - len, - ) +function SCIPsortedvecDelPosLongPtr(longarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), longarray, ptrarray, pos, 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, - ) +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 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{Cuint}, - 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, - ) +function SCIPsortedvecDelPosLongPtrRealBool(longarray, ptrarray, realarray, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, pos, len) end -function SCIPsortDownReal(realarray, len) - ccall( - (:SCIPsortDownReal, libscip), - Cvoid, - (Ptr{Cdouble}, Cint), - realarray, - len, - ) +function SCIPsortedvecDelPosLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, pos, len) end -function SCIPsortDownRealPtr(realarray, ptrarray, len) - ccall( - (:SCIPsortDownRealPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), - realarray, - ptrarray, - len, - ) +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{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, pos, len) end -function SCIPsortDownRealInt(realarray, intarray, len) - ccall( - (:SCIPsortDownRealInt, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Cint), - realarray, - intarray, - len, - ) +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 SCIPsortDownRealIntInt(realarray, intarray1, intarray2, len) - ccall( - (:SCIPsortDownRealIntInt, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), - realarray, - intarray1, - intarray2, - len, - ) +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 SCIPsortDownRealBoolPtr(realarray, boolarray, ptrarray, len) - ccall( - (:SCIPsortDownRealBoolPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), - realarray, - boolarray, - ptrarray, - len, - ) +function SCIPsortedvecDelPosLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) end -function SCIPsortDownRealIntLong(realarray, intarray, longarray, len) - ccall( - (:SCIPsortDownRealIntLong, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint), - realarray, - intarray, - longarray, - len, - ) +function SCIPsortedvecDelPosPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, pos, len) end -function SCIPsortDownRealIntPtr(realarray, intarray, ptrarray, len) - ccall( - (:SCIPsortDownRealIntPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), - realarray, - intarray, - ptrarray, - len, - ) +function SCIPsortedvecDelPosIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) + ccall((:SCIPsortedvecDelPosIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) end -function SCIPsortDownRealRealInt(realarray1, realarray2, intarray, len) - ccall( - (:SCIPsortDownRealRealInt, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint), - realarray1, - realarray2, - intarray, - len, - ) +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 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, - ) +function SCIPsortedvecDelPosDownPtr(ptrarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, pos, 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Ptr{Cvoid}}, - Cint, - ), - realarray1, - realarray2, - realarray3, - boolarray1, - boolarray2, - ptrarray, - len, - ) +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 SCIPsortDownInt(intarray, len) - ccall((:SCIPsortDownInt, libscip), Cvoid, (Ptr{Cint}, Cint), intarray, len) +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 SCIPsortDownIntInt(intarray1, intarray2, len) - ccall( - (:SCIPsortDownIntInt, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Cint), - intarray1, - intarray2, - len, - ) +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 SCIPsortDownIntPtr(intarray, ptrarray, len) - ccall( - (:SCIPsortDownIntPtr, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), - intarray, - ptrarray, - len, - ) +function SCIPsortedvecDelPosDownPtrBool(ptrarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, pos, len) end -function SCIPsortDownIntReal(intarray, realarray, len) - ccall( - (:SCIPsortDownIntReal, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cdouble}, Cint), - intarray, - realarray, - len, - ) +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 SCIPsortDownIntIntInt(intarray1, intarray2, intarray3, len) - ccall( - (:SCIPsortDownIntIntInt, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint), - intarray1, - intarray2, - intarray3, - len, - ) +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 SCIPsortDownIntIntLong(intarray1, intarray2, longarray, len) - ccall( - (:SCIPsortDownIntIntLong, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint), - intarray1, - intarray2, - longarray, - len, - ) +function SCIPsortedvecDelPosDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, pos, len) end -function SCIPsortDownIntIntPtr(intarray1, intarray2, ptrarray, len) - ccall( - (:SCIPsortDownIntIntPtr, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), - intarray1, - intarray2, - ptrarray, - len, - ) +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 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, - ) +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 SCIPsortDownLong(longarray, len) - ccall( - (:SCIPsortDownLong, libscip), - Cvoid, - (Ptr{Clonglong}, Cint), - longarray, - len, - ) +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 SCIPsortDownLongPtr(longarray, ptrarray, len) - ccall( - (:SCIPsortDownLongPtr, libscip), - Cvoid, - (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint), - longarray, - ptrarray, - len, - ) +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 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{Cuint}, 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Cint, - ), - intarray1, - ptrarray, - intarray2, - intarray3, - boolarray1, - boolarray2, - len, - ) +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 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, - ) +function SCIPsortedvecDelPosDownPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) 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{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cuint, - 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 SCIPsortedvecInsertPtrRealRealBoolBool( - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - keyval, - field1val, - field2val, - field3val, - field4val, - len, - pos, -) - ccall( - (:SCIPsortedvecInsertPtrRealRealBoolBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cdouble, - Cdouble, - Cuint, - Cuint, - Ptr{Cint}, - Ptr{Cint}, - ), - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - keyval, - field1val, - field2val, - field3val, - field4val, - len, - pos, - ) -end - -function SCIPsortedvecInsertPtrRealRealIntBool( - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - keyval, - field1val, - field2val, - field3val, - field4val, - len, - pos, -) - ccall( - (:SCIPsortedvecInsertPtrRealRealIntBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cdouble, - Cdouble, - Cint, - Cuint, - Ptr{Cint}, - Ptr{Cint}, - ), - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - keyval, - field1val, - field2val, - field3val, - field4val, - len, - pos, - ) -end - -function SCIPsortedvecInsertPtrRealBool( - ptrarray, - realarray, - boolarray, - ptrcomp, - keyval, - field1val, - field2val, - len, - pos, -) - ccall( - (:SCIPsortedvecInsertPtrRealBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cdouble, - Cuint, - 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{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cdouble, - Cuint, - 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{Cuint}, - Ptr{Ptr{Cvoid}}, - Cdouble, - Cuint, - 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, - ) +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 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{Cuint}, - Ptr{Ptr{Cvoid}}, - Cdouble, - Cdouble, - Cdouble, - Cuint, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Ptr{Cvoid}}, - Cdouble, - Cdouble, - Cdouble, - Cuint, - Cuint, - Ptr{Cvoid}, - Ptr{Cint}, - Ptr{Cint}, - ), - realarray1, - realarray2, - realarray3, - boolarray1, - boolarray2, - ptrarray, - keyval, - field1val, - field2val, - field3val, - field4val, - field5val, - len, - pos, - ) +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 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, - ) +function SCIPsortedvecDelPosDownReal(realarray, pos, len) + ccall((:SCIPsortedvecDelPosDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Ptr{Cint}), realarray, pos, len) 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{Cuint}, - Clonglong, - Ptr{Cvoid}, - Cdouble, - Cuint, - 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{Cuint}, - Clonglong, - Ptr{Cvoid}, - Cdouble, - Cdouble, - Cuint, - 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{Cuint}, - Clonglong, - Ptr{Cvoid}, - Cdouble, - Cdouble, - Cint, - Cuint, - 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{Cuint}, - Ptr{Cint}, - Clonglong, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cuint, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cint, - Cint, - Cuint, - Cuint, - 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{Cuint}, - Ptr{Cuint}, - Cint, - Ptr{Cvoid}, - Cint, - Cint, - Cuint, - Cuint, - 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, - ) +function SCIPsortedvecDelPosDownRealBoolPtr(realarray, boolarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, pos, len) 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{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cuint, - 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{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cdouble, - Cuint, - 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{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cdouble, - Cuint, - 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, - ) +function SCIPsortedvecDelPosDownRealPtr(realarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, ptrarray, pos, len) 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{Cuint}, - Ptr{Ptr{Cvoid}}, - Cdouble, - Cuint, - 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{Cuint}, - Ptr{Ptr{Cvoid}}, - Cdouble, - Cdouble, - Cdouble, - Cuint, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Ptr{Cvoid}}, - Cdouble, - Cdouble, - Cdouble, - Cuint, - Cuint, - Ptr{Cvoid}, - Ptr{Cint}, - Ptr{Cint}, - ), - realarray1, - realarray2, - realarray3, - boolarray1, - boolarray2, - ptrarray, - keyval, - field1val, - field2val, - field3val, - field4val, - field5val, - len, - pos, - ) +function SCIPsortedvecDelPosDownRealInt(realarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, intarray, pos, len) 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, - ) +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 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{Cuint}, - Clonglong, - Ptr{Cvoid}, - Cdouble, - Cuint, - 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{Cuint}, - Clonglong, - Ptr{Cvoid}, - Cdouble, - Cdouble, - Cuint, - 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{Cuint}, - Clonglong, - Ptr{Cvoid}, - Cdouble, - Cdouble, - Cint, - Cuint, - 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{Cuint}, - Ptr{Cint}, - Clonglong, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cuint, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Ptr{Cvoid}, - Cint, - Cint, - Cuint, - Cuint, - 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{Cuint}, - Ptr{Cuint}, - Cint, - Ptr{Cvoid}, - Cint, - Cint, - Cuint, - Cuint, - Ptr{Cint}, - Ptr{Cint}, - ), - intarray1, - ptrarray, - intarray2, - intarray3, - boolarray1, - boolarray2, - keyval, - field1val, - field2val, - field3val, - field4val, - field5val, - len, - pos, - ) +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 SCIPsortedvecDelPosInd(indarray, indcomp, dataptr, pos, len) - ccall( - (:SCIPsortedvecDelPosInd, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), - indarray, - indcomp, - dataptr, - pos, - len, - ) +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 SCIPsortedvecDelPosPtr(ptrarray, ptrcomp, pos, len) - ccall( - (:SCIPsortedvecDelPosPtr, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), - ptrarray, - ptrcomp, - pos, - len, - ) +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 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, - ) +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 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, - ) +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 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, - ) +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 SCIPsortedvecDelPosPtrBool(ptrarray, boolarray, ptrcomp, pos, len) - ccall( - (:SCIPsortedvecDelPosPtrBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, 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 SCIPsortedvecDelPosPtrRealRealBoolBool( - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - pos, - len, -) - ccall( - (:SCIPsortedvecDelPosPtrRealRealBoolBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Cint, - Ptr{Cint}, - ), - ptrarray, - realarray1, - realarray2, - boolarray1, - boolarray2, - ptrcomp, - pos, - len, - ) -end - -function SCIPsortedvecDelPosPtrRealRealIntBool( - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - pos, - len, -) - ccall( - (:SCIPsortedvecDelPosPtrRealRealIntBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cuint}, - Ptr{Cvoid}, - Cint, - Ptr{Cint}, - ), - ptrarray, - realarray1, - realarray2, - intarray, - boolarray, - ptrcomp, - pos, - len, - ) -end - -function SCIPsortedvecDelPosPtrRealBool( - ptrarray, - realarray, - boolarray, - ptrcomp, - pos, - len, -) - ccall( - (:SCIPsortedvecDelPosPtrRealBool, libscip), - Cvoid, - ( - Ptr{Ptr{Cvoid}}, - Ptr{Cdouble}, - Ptr{Cuint}, - 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{Cuint}, - 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{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), - realarray, - boolarray, - ptrarray, - pos, - len, - ) +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 SCIPsortedvecDelPosRealPtr(realarray, ptrarray, pos, len) - ccall( - (:SCIPsortedvecDelPosRealPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), - realarray, - ptrarray, - pos, - len, - ) +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 SCIPsortedvecDelPosReal(realarray, pos, len) - ccall( - (:SCIPsortedvecDelPosReal, libscip), - Cvoid, - (Ptr{Cdouble}, Cint, Ptr{Cint}), - realarray, - pos, - len, - ) +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 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, - ) +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 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Ptr{Cvoid}}, - Cint, - Ptr{Cint}, - ), - realarray1, - realarray2, - realarray3, - boolarray1, - boolarray2, - ptrarray, - pos, - len, - ) +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 SCIPsortedvecDelPosInt(intarray, pos, len) - ccall( - (:SCIPsortedvecDelPosInt, libscip), - Cvoid, - (Ptr{Cint}, Cint, Ptr{Cint}), - intarray, - pos, - len, - ) +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 SCIPsortedvecDelPosIntInt(intarray1, intarray2, pos, len) - ccall( - (:SCIPsortedvecDelPosIntInt, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), - intarray1, - intarray2, - pos, - len, - ) +function SCIPsortedvecDelPosDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) end -function SCIPsortedvecDelPosIntReal(intarray, realarray, pos, len) - ccall( - (:SCIPsortedvecDelPosIntReal, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), - intarray, - realarray, - pos, - len, - ) +function SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, 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, - ) +function SCIPsortedvecDelPosDownInt(intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}), intarray, 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, - ) +function SCIPsortedvecDelPosDownIntInt(intarray1, intarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), intarray1, intarray2, 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, - ) +function SCIPsortedvecDelPosDownIntReal(intarray, realarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray, realarray, 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, - ) +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 SCIPsortedvecDelPosLong(longarray, pos, len) - ccall( - (:SCIPsortedvecDelPosLong, libscip), - Cvoid, - (Ptr{Clonglong}, Cint, Ptr{Cint}), - longarray, - pos, - len, - ) +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 SCIPsortedvecDelPosLongPtr(longarray, ptrarray, pos, len) - ccall( - (:SCIPsortedvecDelPosLongPtr, libscip), - Cvoid, - (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), - longarray, - ptrarray, - pos, - len, - ) +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 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Cint, - Ptr{Cint}, - ), - intarray1, - ptrarray, - intarray2, - intarray3, - boolarray1, - boolarray2, - pos, - len, - ) +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 SCIPsortedvecDelPosDownInd(indarray, indcomp, dataptr, pos, len) - ccall( - (:SCIPsortedvecDelPosDownInd, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), - indarray, - indcomp, - dataptr, - pos, - len, - ) +function SCIPsortedvecDelPosDownIntPtr(intarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray, ptrarray, 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, - ) +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 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, - ) +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 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, - ) +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 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, - ) +function SCIPsortedvecDelPosDownLong(longarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Ptr{Cint}), longarray, pos, len) end -function SCIPsortedvecDelPosDownPtrBool(ptrarray, boolarray, ptrcomp, pos, len) - ccall( - (:SCIPsortedvecDelPosDownPtrBool, libscip), - Cvoid, - (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, 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{Cuint}, - 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{Cuint}, - 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, - ) +function SCIPsortedvecDelPosDownLongPtr(longarray, ptrarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtr, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), longarray, ptrarray, 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{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), - realarray, - boolarray, - ptrarray, - pos, - len, - ) +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 SCIPsortedvecDelPosDownRealPtr(realarray, ptrarray, pos, len) - ccall( - (:SCIPsortedvecDelPosDownRealPtr, libscip), - Cvoid, - (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), - realarray, - ptrarray, - pos, - len, - ) +function SCIPsortedvecDelPosDownLongPtrRealBool(longarray, ptrarray, realarray, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Ptr{Ptr{Cvoid}}, - Cint, - Ptr{Cint}, - ), - realarray1, - realarray2, - realarray3, - boolarray1, - boolarray2, - ptrarray, - pos, - len, - ) +function SCIPsortedvecDelPosDownLongPtrRealRealBool(longarray, ptrarray, realarray, realarray2, boolarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrRealRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, pos, len) end -function SCIPsortedvecDelPosDownInt(intarray, pos, len) - ccall( - (:SCIPsortedvecDelPosDownInt, libscip), - Cvoid, - (Ptr{Cint}, Cint, Ptr{Cint}), - intarray, - pos, - len, - ) +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{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, pos, len) end -function SCIPsortedvecDelPosDownIntInt(intarray1, intarray2, pos, len) - ccall( - (:SCIPsortedvecDelPosDownIntInt, libscip), - Cvoid, - (Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), - intarray1, - intarray2, - pos, - len, - ) +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 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, - ) +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 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, - ) +function SCIPsortedvecDelPosDownLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) + ccall((:SCIPsortedvecDelPosDownLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) end -function SCIPsortedvecDelPosDownLong(longarray, pos, len) - ccall( - (:SCIPsortedvecDelPosDownLong, libscip), - Cvoid, - (Ptr{Clonglong}, Cint, Ptr{Cint}), - longarray, - pos, - len, - ) +function SCIPsortedvecDelPosDownPtrIntIntBoolBool(ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, pos, len) + ccall((:SCIPsortedvecDelPosDownPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - 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{Cuint}, - Ptr{Cuint}, - Cint, - Ptr{Cint}, - ), - intarray1, - ptrarray, - intarray2, - intarray3, - boolarray1, - boolarray2, - pos, - len, - ) +function SCIPsortedvecDelPosDownIntPtrIntIntBoolBool(intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) + ccall((:SCIPsortedvecDelPosDownIntPtrIntIntBoolBool, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) end function SCIPsortedvecFindInd(indarray, indcomp, dataptr, val, len, pos) - ccall( - (:SCIPsortedvecFindInd, libscip), - Cuint, - (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}), - indarray, - indcomp, - dataptr, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindInd, libscip), Cuint, (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), - Cuint, - (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), - ptrarray, - ptrcomp, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindPtr, libscip), Cuint, (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), - Cuint, - (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), - realarray, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindReal, libscip), Cuint, (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, val, len, pos) end function SCIPsortedvecFindInt(intarray, val, len, pos) - ccall( - (:SCIPsortedvecFindInt, libscip), - Cuint, - (Ptr{Cint}, Cint, Cint, Ptr{Cint}), - intarray, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindInt, libscip), Cuint, (Ptr{Cint}, Cint, Cint, Ptr{Cint}), intarray, val, len, pos) end function SCIPsortedvecFindLong(longarray, val, len, pos) - ccall( - (:SCIPsortedvecFindLong, libscip), - Cuint, - (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), - longarray, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindLong, libscip), Cuint, (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), longarray, val, len, pos) end function SCIPsortedvecFindDownInd(indarray, indcomp, dataptr, val, len, pos) - ccall( - (:SCIPsortedvecFindDownInd, libscip), - Cuint, - (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}), - indarray, - indcomp, - dataptr, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindDownInd, libscip), Cuint, (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), - Cuint, - (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), - ptrarray, - ptrcomp, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindDownPtr, libscip), Cuint, (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), - Cuint, - (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), - realarray, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindDownReal, libscip), Cuint, (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, val, len, pos) end function SCIPsortedvecFindDownInt(intarray, val, len, pos) - ccall( - (:SCIPsortedvecFindDownInt, libscip), - Cuint, - (Ptr{Cint}, Cint, Cint, Ptr{Cint}), - intarray, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindDownInt, libscip), Cuint, (Ptr{Cint}, Cint, Cint, Ptr{Cint}), intarray, val, len, pos) end function SCIPsortedvecFindDownLong(longarray, val, len, pos) - ccall( - (:SCIPsortedvecFindDownLong, libscip), - Cuint, - (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), - longarray, - val, - len, - pos, - ) + ccall((:SCIPsortedvecFindDownLong, libscip), Cuint, (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), longarray, val, len, pos) +end + +const SCIP_Netmatdec = Cvoid + +const SCIP_NETMATDEC = SCIP_Netmatdec + +function SCIPnetmatdecCreate(blkmem, pdec, nrows, ncols) + ccall((:SCIPnetmatdecCreate, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_NETMATDEC}}, Cint, Cint), blkmem, pdec, nrows, ncols) +end + +function SCIPnetmatdecFree(pdec) + ccall((:SCIPnetmatdecFree, libscip), Cvoid, (Ptr{Ptr{SCIP_NETMATDEC}},), pdec) +end + +function SCIPnetmatdecTryAddCol(dec, column, nonzrows, nonzvals, nnonzs, success) + ccall((:SCIPnetmatdecTryAddCol, libscip), SCIP_RETCODE, (Ptr{SCIP_NETMATDEC}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cuint}), dec, column, nonzrows, nonzvals, nnonzs, success) +end + +function SCIPnetmatdecTryAddRow(dec, row, nonzcols, nonzvals, nnonzs, success) + ccall((:SCIPnetmatdecTryAddRow, libscip), SCIP_RETCODE, (Ptr{SCIP_NETMATDEC}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cuint}), dec, row, nonzcols, nonzvals, nnonzs, success) +end + +function SCIPnetmatdecContainsRow(dec, row) + ccall((:SCIPnetmatdecContainsRow, libscip), Cuint, (Ptr{SCIP_NETMATDEC}, Cint), dec, row) +end + +function SCIPnetmatdecContainsColumn(dec, column) + ccall((:SCIPnetmatdecContainsColumn, libscip), Cuint, (Ptr{SCIP_NETMATDEC}, Cint), dec, column) +end + +function SCIPnetmatdecRemoveComponent(dec, componentrows, nrows, componentcols, ncols) + ccall((:SCIPnetmatdecRemoveComponent, libscip), Cvoid, (Ptr{SCIP_NETMATDEC}, Ptr{Cint}, Cint, Ptr{Cint}, Cint), dec, componentrows, nrows, componentcols, ncols) +end + +function SCIPnetmatdecIsMinimal(dec) + ccall((:SCIPnetmatdecIsMinimal, libscip), Cuint, (Ptr{SCIP_NETMATDEC},), dec) +end + +function SCIPnetmatdecVerifyCycle(bufmem, dec, column, nonzrowidx, nonzvals, nnonzs, pathrowstorage, pathsignstorage) + ccall((:SCIPnetmatdecVerifyCycle, libscip), Cuint, (Ptr{BMS_BUFMEM}, Ptr{SCIP_NETMATDEC}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}, Ptr{Cuint}), bufmem, dec, column, nonzrowidx, nonzvals, nnonzs, pathrowstorage, pathsignstorage) +end + +function SCIPnetmatdecCreateDiGraph(dec, blkmem, pdigraph, createrowarcs) + ccall((:SCIPnetmatdecCreateDiGraph, libscip), SCIP_RETCODE, (Ptr{SCIP_NETMATDEC}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_DIGRAPH}}, Cuint), dec, blkmem, pdigraph, createrowarcs) end function SCIPnlhdlrSetCopyHdlr(nlhdlr, copy) - ccall( - (:SCIPnlhdlrSetCopyHdlr, libscip), - Cvoid, - (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), - nlhdlr, - copy, - ) + ccall((:SCIPnlhdlrSetCopyHdlr, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), nlhdlr, copy) end function SCIPnlhdlrSetFreeHdlrData(nlhdlr, freehdlrdata) - ccall( - (:SCIPnlhdlrSetFreeHdlrData, libscip), - Cvoid, - (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), - nlhdlr, - freehdlrdata, - ) + ccall((:SCIPnlhdlrSetFreeHdlrData, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), nlhdlr, freehdlrdata) end function SCIPnlhdlrSetFreeExprData(nlhdlr, freeexprdata) - ccall( - (:SCIPnlhdlrSetFreeExprData, libscip), - Cvoid, - (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), - nlhdlr, - freeexprdata, - ) + ccall((:SCIPnlhdlrSetFreeExprData, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), nlhdlr, freeexprdata) end function SCIPnlhdlrSetInitExit(nlhdlr, init, exit) - ccall( - (:SCIPnlhdlrSetInitExit, libscip), - Cvoid, - (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), - nlhdlr, - init, - exit, - ) + ccall((:SCIPnlhdlrSetInitExit, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), nlhdlr, init, exit) end function SCIPnlhdlrSetProp(nlhdlr, inteval, reverseprop) - ccall( - (:SCIPnlhdlrSetProp, libscip), - Cvoid, - (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), - nlhdlr, - inteval, - reverseprop, - ) + ccall((:SCIPnlhdlrSetProp, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), nlhdlr, inteval, reverseprop) end function SCIPnlhdlrSetSepa(nlhdlr, initsepa, enfo, estimate, exitsepa) - ccall( - (:SCIPnlhdlrSetSepa, libscip), - Cvoid, - (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), - nlhdlr, - initsepa, - enfo, - estimate, - exitsepa, - ) + ccall((:SCIPnlhdlrSetSepa, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), nlhdlr, initsepa, enfo, estimate, exitsepa) +end + +function SCIPnlhdlrSetSollinearize(nlhdlr, sollinearize) + ccall((:SCIPnlhdlrSetSollinearize, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), nlhdlr, sollinearize) end function SCIPnlhdlrGetName(nlhdlr) - ccall( - (:SCIPnlhdlrGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) + ccall((:SCIPnlhdlrGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_NLHDLR},), nlhdlr) end function SCIPnlhdlrGetDesc(nlhdlr) - ccall( - (:SCIPnlhdlrGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) + ccall((:SCIPnlhdlrGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_NLHDLR},), nlhdlr) end function SCIPnlhdlrGetDetectPriority(nlhdlr) - ccall( - (:SCIPnlhdlrGetDetectPriority, libscip), - Cint, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) + ccall((:SCIPnlhdlrGetDetectPriority, libscip), Cint, (Ptr{SCIP_NLHDLR},), nlhdlr) end function SCIPnlhdlrGetEnfoPriority(nlhdlr) - ccall( - (:SCIPnlhdlrGetEnfoPriority, libscip), - Cint, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) + ccall((:SCIPnlhdlrGetEnfoPriority, libscip), Cint, (Ptr{SCIP_NLHDLR},), nlhdlr) end function SCIPnlhdlrIsEnabled(nlhdlr) @@ -58690,12 +23509,7 @@ function SCIPnlhdlrIsEnabled(nlhdlr) end function SCIPnlhdlrGetData(nlhdlr) - ccall( - (:SCIPnlhdlrGetData, libscip), - Ptr{SCIP_NLHDLRDATA}, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) + ccall((:SCIPnlhdlrGetData, libscip), Ptr{SCIP_NLHDLRDATA}, (Ptr{SCIP_NLHDLR},), nlhdlr) end function SCIPnlhdlrHasIntEval(nlhdlr) @@ -58703,12 +23517,7 @@ function SCIPnlhdlrHasIntEval(nlhdlr) end function SCIPnlhdlrHasReverseProp(nlhdlr) - ccall( - (:SCIPnlhdlrHasReverseProp, libscip), - Cuint, - (Ptr{SCIP_NLHDLR},), - nlhdlr, - ) + ccall((:SCIPnlhdlrHasReverseProp, libscip), Cuint, (Ptr{SCIP_NLHDLR},), nlhdlr) end function SCIPnlhdlrHasInitSepa(nlhdlr) @@ -58727,14 +23536,12 @@ function SCIPnlhdlrHasEstimate(nlhdlr) ccall((:SCIPnlhdlrHasEstimate, libscip), Cuint, (Ptr{SCIP_NLHDLR},), nlhdlr) end +function SCIPnlhdlrHasSollinearize(nlhdlr) + ccall((:SCIPnlhdlrHasSollinearize, libscip), Cuint, (Ptr{SCIP_NLHDLR},), nlhdlr) +end + function SCIPnlhdlrComp(elem1, elem2) - ccall( - (:SCIPnlhdlrComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) + ccall((:SCIPnlhdlrComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) end function SCIPnlrowGetConstant(nlrow) @@ -58746,30 +23553,15 @@ function SCIPnlrowGetNLinearVars(nlrow) end function SCIPnlrowGetLinearVars(nlrow) - ccall( - (:SCIPnlrowGetLinearVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_NLROW},), - 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, - ) + ccall((:SCIPnlrowGetLinearCoefs, libscip), Ptr{Cdouble}, (Ptr{SCIP_NLROW},), nlrow) end function SCIPnlrowGetExpr(nlrow) - ccall( - (:SCIPnlrowGetExpr, libscip), - Ptr{SCIP_EXPR}, - (Ptr{SCIP_NLROW},), - nlrow, - ) + ccall((:SCIPnlrowGetExpr, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_NLROW},), nlrow) end function SCIPnlrowGetLhs(nlrow) @@ -58781,22 +23573,7 @@ function SCIPnlrowGetRhs(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, - ) + ccall((:SCIPnlrowGetCurvature, libscip), SCIP_EXPRCURV, (Ptr{SCIP_NLROW},), nlrow) end function SCIPnlrowGetName(nlrow) @@ -58816,22 +23593,11 @@ function SCIPnlrowGetDualsol(nlrow) end function SCIPnlpiComp(elem1, elem2) - ccall( - (:SCIPnlpiComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - elem1, - elem2, - ) + ccall((:SCIPnlpiComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) end function SCIPnlpiGetData(nlpi) - ccall( - (:SCIPnlpiGetData, libscip), - Ptr{SCIP_NLPIDATA}, - (Ptr{SCIP_NLPI},), - nlpi, - ) + ccall((:SCIPnlpiGetData, libscip), Ptr{SCIP_NLPIDATA}, (Ptr{SCIP_NLPI},), nlpi) end function SCIPnlpiGetName(nlpi) @@ -58867,134 +23633,59 @@ function SCIPnlpiGetEvalTime(nlpi) end function SCIPnlpiGetNIterations(nlpi) - ccall( - (:SCIPnlpiGetNIterations, libscip), - Clonglong, - (Ptr{SCIP_NLPI},), - nlpi, - ) + ccall((:SCIPnlpiGetNIterations, libscip), Clonglong, (Ptr{SCIP_NLPI},), nlpi) end function SCIPnlpiGetNTermStat(nlpi, termstatus) - ccall( - (:SCIPnlpiGetNTermStat, libscip), - Cint, - (Ptr{SCIP_NLPI}, SCIP_NLPTERMSTAT), - nlpi, - termstatus, - ) + ccall((:SCIPnlpiGetNTermStat, libscip), Cint, (Ptr{SCIP_NLPI}, SCIP_NLPTERMSTAT), nlpi, termstatus) end function SCIPnlpiGetNSolStat(nlpi, solstatus) - ccall( - (:SCIPnlpiGetNSolStat, libscip), - Cint, - (Ptr{SCIP_NLPI}, SCIP_NLPSOLSTAT), - nlpi, - solstatus, - ) + ccall((:SCIPnlpiGetNSolStat, libscip), Cint, (Ptr{SCIP_NLPI}, SCIP_NLPSOLSTAT), nlpi, solstatus) end function SCIPnlpiMergeStatistics(targetnlpi, sourcenlpi, reset) - ccall( - (:SCIPnlpiMergeStatistics, libscip), - Cvoid, - (Ptr{SCIP_NLPI}, Ptr{SCIP_NLPI}, Cuint), - targetnlpi, - sourcenlpi, - reset, - ) + ccall((:SCIPnlpiMergeStatistics, libscip), Cvoid, (Ptr{SCIP_NLPI}, Ptr{SCIP_NLPI}, Cuint), targetnlpi, sourcenlpi, reset) end function SCIPnodeselGetName(nodesel) - ccall( - (:SCIPnodeselGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_NODESEL},), - nodesel, - ) + ccall((:SCIPnodeselGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_NODESEL},), nodesel) end function SCIPnodeselGetDesc(nodesel) - ccall( - (:SCIPnodeselGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_NODESEL},), - nodesel, - ) + ccall((:SCIPnodeselGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_NODESEL},), nodesel) end function SCIPnodeselGetStdPriority(nodesel) - ccall( - (:SCIPnodeselGetStdPriority, libscip), - Cint, - (Ptr{SCIP_NODESEL},), - nodesel, - ) + ccall((:SCIPnodeselGetStdPriority, libscip), Cint, (Ptr{SCIP_NODESEL},), nodesel) end function SCIPnodeselGetMemsavePriority(nodesel) - ccall( - (:SCIPnodeselGetMemsavePriority, libscip), - Cint, - (Ptr{SCIP_NODESEL},), - nodesel, - ) + ccall((:SCIPnodeselGetMemsavePriority, libscip), Cint, (Ptr{SCIP_NODESEL},), nodesel) end function SCIPnodeselGetData(nodesel) - ccall( - (:SCIPnodeselGetData, libscip), - Ptr{SCIP_NODESELDATA}, - (Ptr{SCIP_NODESEL},), - 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, - ) + ccall((:SCIPnodeselSetData, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{SCIP_NODESELDATA}), nodesel, nodeseldata) end function SCIPnodeselIsInitialized(nodesel) - ccall( - (:SCIPnodeselIsInitialized, libscip), - Cuint, - (Ptr{SCIP_NODESEL},), - nodesel, - ) + ccall((:SCIPnodeselIsInitialized, libscip), Cuint, (Ptr{SCIP_NODESEL},), nodesel) end function SCIPnodeselGetSetupTime(nodesel) - ccall( - (:SCIPnodeselGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_NODESEL},), - nodesel, - ) + ccall((:SCIPnodeselGetSetupTime, libscip), Cdouble, (Ptr{SCIP_NODESEL},), nodesel) end function SCIPnodeselGetTime(nodesel) - ccall( - (:SCIPnodeselGetTime, libscip), - Cdouble, - (Ptr{SCIP_NODESEL},), - nodesel, - ) + ccall((:SCIPnodeselGetTime, libscip), Cdouble, (Ptr{SCIP_NODESEL},), nodesel) end function SCIPparamGetType(param) - ccall( - (:SCIPparamGetType, libscip), - SCIP_PARAMTYPE, - (Ptr{SCIP_PARAM},), - param, - ) + ccall((:SCIPparamGetType, libscip), SCIP_PARAMTYPE, (Ptr{SCIP_PARAM},), param) end function SCIPparamGetName(param) @@ -59006,12 +23697,7 @@ function SCIPparamGetDesc(param) end function SCIPparamGetData(param) - ccall( - (:SCIPparamGetData, libscip), - Ptr{SCIP_PARAMDATA}, - (Ptr{SCIP_PARAM},), - param, - ) + ccall((:SCIPparamGetData, libscip), Ptr{SCIP_PARAMDATA}, (Ptr{SCIP_PARAM},), param) end function SCIPparamIsAdvanced(param) @@ -59023,13 +23709,7 @@ function SCIPparamIsFixed(param) end function SCIPparamSetFixed(param, fixed) - ccall( - (:SCIPparamSetFixed, libscip), - Cvoid, - (Ptr{SCIP_PARAM}, Cuint), - param, - fixed, - ) + ccall((:SCIPparamSetFixed, libscip), Cvoid, (Ptr{SCIP_PARAM}, Cuint), param, fixed) end function SCIPparamGetBool(param) @@ -59061,30 +23741,15 @@ function SCIPparamGetLongint(param) end function SCIPparamGetLongintMin(param) - ccall( - (:SCIPparamGetLongintMin, libscip), - Clonglong, - (Ptr{SCIP_PARAM},), - param, - ) + ccall((:SCIPparamGetLongintMin, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) end function SCIPparamGetLongintMax(param) - ccall( - (:SCIPparamGetLongintMax, libscip), - Clonglong, - (Ptr{SCIP_PARAM},), - param, - ) + ccall((:SCIPparamGetLongintMax, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) end function SCIPparamGetLongintDefault(param) - ccall( - (:SCIPparamGetLongintDefault, libscip), - Clonglong, - (Ptr{SCIP_PARAM},), - param, - ) + ccall((:SCIPparamGetLongintDefault, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) end function SCIPparamGetReal(param) @@ -59100,12 +23765,7 @@ function SCIPparamGetRealMax(param) end function SCIPparamGetRealDefault(param) - ccall( - (:SCIPparamGetRealDefault, libscip), - Cdouble, - (Ptr{SCIP_PARAM},), - param, - ) + ccall((:SCIPparamGetRealDefault, libscip), Cdouble, (Ptr{SCIP_PARAM},), param) end function SCIPparamGetChar(param) @@ -59113,12 +23773,7 @@ function SCIPparamGetChar(param) end function SCIPparamGetCharAllowedValues(param) - ccall( - (:SCIPparamGetCharAllowedValues, libscip), - Ptr{Cchar}, - (Ptr{SCIP_PARAM},), - param, - ) + ccall((:SCIPparamGetCharAllowedValues, libscip), Ptr{Cchar}, (Ptr{SCIP_PARAM},), param) end function SCIPparamGetCharDefault(param) @@ -59130,12 +23785,7 @@ function SCIPparamGetString(param) end function SCIPparamGetStringDefault(param) - ccall( - (:SCIPparamGetStringDefault, libscip), - Ptr{Cchar}, - (Ptr{SCIP_PARAM},), - param, - ) + ccall((:SCIPparamGetStringDefault, libscip), Ptr{Cchar}, (Ptr{SCIP_PARAM},), param) end function SCIPparamIsDefault(param) @@ -59143,60 +23793,31 @@ function SCIPparamIsDefault(param) end function SCIPpresolComp(elem1, elem2) - ccall( - (:SCIPpresolComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - 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, - ) + ccall((:SCIPpresolCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) end function SCIPpresolGetData(presol) - ccall( - (:SCIPpresolGetData, libscip), - Ptr{SCIP_PRESOLDATA}, - (Ptr{SCIP_PRESOL},), - 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, - ) + ccall((:SCIPpresolSetData, libscip), Cvoid, (Ptr{SCIP_PRESOL}, Ptr{SCIP_PRESOLDATA}), presol, presoldata) +end + +function SCIPpresolMarkExact(presol) + ccall((:SCIPpresolMarkExact, libscip), Cvoid, (Ptr{SCIP_PRESOL},), presol) end function SCIPpresolGetName(presol) - ccall( - (:SCIPpresolGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_PRESOL},), - presol, - ) + ccall((:SCIPpresolGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_PRESOL},), presol) end function SCIPpresolGetDesc(presol) - ccall( - (:SCIPpresolGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_PRESOL},), - presol, - ) + ccall((:SCIPpresolGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_PRESOL},), presol) end function SCIPpresolGetPriority(presol) @@ -59208,40 +23829,19 @@ function SCIPpresolGetMaxrounds(presol) end function SCIPpresolGetTiming(presol) - ccall( - (:SCIPpresolGetTiming, libscip), - SCIP_PRESOLTIMING, - (Ptr{SCIP_PRESOL},), - 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, - ) + ccall((:SCIPpresolSetTiming, libscip), Cvoid, (Ptr{SCIP_PRESOL}, SCIP_PRESOLTIMING), presol, timing) end function SCIPpresolIsInitialized(presol) - ccall( - (:SCIPpresolIsInitialized, libscip), - Cuint, - (Ptr{SCIP_PRESOL},), - presol, - ) + ccall((:SCIPpresolIsInitialized, libscip), Cuint, (Ptr{SCIP_PRESOL},), presol) end function SCIPpresolGetSetupTime(presol) - ccall( - (:SCIPpresolGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_PRESOL},), - presol, - ) + ccall((:SCIPpresolGetSetupTime, libscip), Cdouble, (Ptr{SCIP_PRESOL},), presol) end function SCIPpresolGetTime(presol) @@ -59249,12 +23849,7 @@ function SCIPpresolGetTime(presol) end function SCIPpresolGetNFixedVars(presol) - ccall( - (:SCIPpresolGetNFixedVars, libscip), - Cint, - (Ptr{SCIP_PRESOL},), - presol, - ) + ccall((:SCIPpresolGetNFixedVars, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) end function SCIPpresolGetNAggrVars(presol) @@ -59262,12 +23857,7 @@ function SCIPpresolGetNAggrVars(presol) end function SCIPpresolGetNChgVarTypes(presol) - ccall( - (:SCIPpresolGetNChgVarTypes, libscip), - Cint, - (Ptr{SCIP_PRESOL},), - presol, - ) + ccall((:SCIPpresolGetNChgVarTypes, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) end function SCIPpresolGetNChgBds(presol) @@ -59287,12 +23877,7 @@ function SCIPpresolGetNAddConss(presol) end function SCIPpresolGetNUpgdConss(presol) - ccall( - (:SCIPpresolGetNUpgdConss, libscip), - Cint, - (Ptr{SCIP_PRESOL},), - presol, - ) + ccall((:SCIPpresolGetNUpgdConss, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) end function SCIPpresolGetNChgCoefs(presol) @@ -59308,60 +23893,31 @@ function SCIPpresolGetNCalls(presol) end function SCIPpricerComp(elem1, elem2) - ccall( - (:SCIPpricerComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - 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, - ) + ccall((:SCIPpricerCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) end function SCIPpricerGetData(pricer) - ccall( - (:SCIPpricerGetData, libscip), - Ptr{SCIP_PRICERDATA}, - (Ptr{SCIP_PRICER},), - 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, - ) + ccall((:SCIPpricerSetData, libscip), Cvoid, (Ptr{SCIP_PRICER}, Ptr{SCIP_PRICERDATA}), pricer, pricerdata) +end + +function SCIPpricerMarkExact(pricer) + ccall((:SCIPpricerMarkExact, libscip), Cvoid, (Ptr{SCIP_PRICER},), pricer) end function SCIPpricerGetName(pricer) - ccall( - (:SCIPpricerGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_PRICER},), - pricer, - ) + ccall((:SCIPpricerGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_PRICER},), pricer) end function SCIPpricerGetDesc(pricer) - ccall( - (:SCIPpricerGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_PRICER},), - pricer, - ) + ccall((:SCIPpricerGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_PRICER},), pricer) end function SCIPpricerGetPriority(pricer) @@ -59373,21 +23929,11 @@ function SCIPpricerGetNCalls(pricer) end function SCIPpricerGetNVarsFound(pricer) - ccall( - (:SCIPpricerGetNVarsFound, libscip), - Cint, - (Ptr{SCIP_PRICER},), - pricer, - ) + ccall((:SCIPpricerGetNVarsFound, libscip), Cint, (Ptr{SCIP_PRICER},), pricer) end function SCIPpricerGetSetupTime(pricer) - ccall( - (:SCIPpricerGetSetupTime, libscip), - Cdouble, - (Ptr{SCIP_PRICER},), - pricer, - ) + ccall((:SCIPpricerGetSetupTime, libscip), Cdouble, (Ptr{SCIP_PRICER},), pricer) end function SCIPpricerGetTime(pricer) @@ -59403,61 +23949,31 @@ function SCIPpricerIsDelayed(pricer) end function SCIPpricerIsInitialized(pricer) - ccall( - (:SCIPpricerIsInitialized, libscip), - Cuint, - (Ptr{SCIP_PRICER},), - pricer, - ) + ccall((:SCIPpricerIsInitialized, libscip), Cuint, (Ptr{SCIP_PRICER},), pricer) end function SCIPpropComp(elem1, elem2) - ccall( - (:SCIPpropComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - 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, - ) + 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, - ) + ccall((:SCIPpropCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) end function SCIPpropGetData(prop) - ccall( - (:SCIPpropGetData, libscip), - Ptr{SCIP_PROPDATA}, - (Ptr{SCIP_PROP},), - 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, - ) + ccall((:SCIPpropSetData, libscip), Cvoid, (Ptr{SCIP_PROP}, Ptr{SCIP_PROPDATA}), prop, propdata) +end + +function SCIPpropMarkExact(prop) + ccall((:SCIPpropMarkExact, libscip), Cvoid, (Ptr{SCIP_PROP},), prop) end function SCIPpropGetName(prop) @@ -59485,13 +24001,7 @@ function SCIPpropGetSetupTime(prop) end function SCIPpropSetFreq(prop, freq) - ccall( - (:SCIPpropSetFreq, libscip), - Cvoid, - (Ptr{SCIP_PROP}, Cint), - prop, - freq, - ) + ccall((:SCIPpropSetFreq, libscip), Cvoid, (Ptr{SCIP_PROP}, Cint), prop, freq) end function SCIPpropGetTime(prop) @@ -59499,12 +24009,7 @@ function SCIPpropGetTime(prop) end function SCIPpropGetStrongBranchPropTime(prop) - ccall( - (:SCIPpropGetStrongBranchPropTime, libscip), - Cdouble, - (Ptr{SCIP_PROP},), - prop, - ) + ccall((:SCIPpropGetStrongBranchPropTime, libscip), Cdouble, (Ptr{SCIP_PROP},), prop) end function SCIPpropGetRespropTime(prop) @@ -59520,12 +24025,7 @@ function SCIPpropGetNCalls(prop) end function SCIPpropGetNRespropCalls(prop) - ccall( - (:SCIPpropGetNRespropCalls, libscip), - Clonglong, - (Ptr{SCIP_PROP},), - prop, - ) + ccall((:SCIPpropGetNRespropCalls, libscip), Clonglong, (Ptr{SCIP_PROP},), prop) end function SCIPpropGetNCutoffs(prop) @@ -59533,12 +24033,7 @@ function SCIPpropGetNCutoffs(prop) end function SCIPpropGetNDomredsFound(prop) - ccall( - (:SCIPpropGetNDomredsFound, libscip), - Clonglong, - (Ptr{SCIP_PROP},), - prop, - ) + ccall((:SCIPpropGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_PROP},), prop) end function SCIPpropIsDelayed(prop) @@ -59598,12 +24093,11 @@ function SCIPpropGetNPresolCalls(prop) end function SCIPpropGetTimingmask(prop) - ccall( - (:SCIPpropGetTimingmask, libscip), - SCIP_PROPTIMING, - (Ptr{SCIP_PROP},), - prop, - ) + ccall((:SCIPpropGetTimingmask, libscip), SCIP_PROPTIMING, (Ptr{SCIP_PROP},), prop) +end + +function SCIPpropSetTimingmask(prop, timingmask) + ccall((:SCIPpropSetTimingmask, libscip), Cvoid, (Ptr{SCIP_PROP}, SCIP_PROPTIMING), prop, timingmask) end function SCIPpropDoesPresolve(prop) @@ -59611,68 +24105,35 @@ function SCIPpropDoesPresolve(prop) end function SCIPpropGetPresolTiming(prop) - ccall( - (:SCIPpropGetPresolTiming, libscip), - SCIP_PRESOLTIMING, - (Ptr{SCIP_PROP},), - 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, - ) + ccall((:SCIPpropSetPresolTiming, libscip), Cvoid, (Ptr{SCIP_PROP}, SCIP_PRESOLTIMING), prop, presoltiming) end function SCIPreaderGetData(reader) - ccall( - (:SCIPreaderGetData, libscip), - Ptr{SCIP_READERDATA}, - (Ptr{SCIP_READER},), - 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, - ) + ccall((:SCIPreaderSetData, libscip), Cvoid, (Ptr{SCIP_READER}, Ptr{SCIP_READERDATA}), reader, readerdata) +end + +function SCIPreaderMarkExact(reader) + ccall((:SCIPreaderMarkExact, libscip), Cvoid, (Ptr{SCIP_READER},), reader) end function SCIPreaderGetName(reader) - ccall( - (:SCIPreaderGetName, libscip), - Ptr{Cchar}, - (Ptr{SCIP_READER},), - reader, - ) + ccall((:SCIPreaderGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_READER},), reader) end function SCIPreaderGetDesc(reader) - ccall( - (:SCIPreaderGetDesc, libscip), - Ptr{Cchar}, - (Ptr{SCIP_READER},), - reader, - ) + ccall((:SCIPreaderGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_READER},), reader) end function SCIPreaderGetExtension(reader) - ccall( - (:SCIPreaderGetExtension, libscip), - Ptr{Cchar}, - (Ptr{SCIP_READER},), - reader, - ) + ccall((:SCIPreaderGetExtension, libscip), Ptr{Cchar}, (Ptr{SCIP_READER},), reader) end function SCIPreaderCanRead(reader) @@ -59684,42 +24145,23 @@ function SCIPreaderCanWrite(reader) end function SCIPrelaxComp(elem1, elem2) - ccall( - (:SCIPrelaxComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - 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, - ) + ccall((:SCIPrelaxCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) end function SCIPrelaxGetData(relax) - ccall( - (:SCIPrelaxGetData, libscip), - Ptr{SCIP_RELAXDATA}, - (Ptr{SCIP_RELAX},), - 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, - ) + ccall((:SCIPrelaxSetData, libscip), Cvoid, (Ptr{SCIP_RELAX}, Ptr{SCIP_RELAXDATA}), relax, relaxdata) +end + +function SCIPrelaxMarkExact(relax) + ccall((:SCIPrelaxMarkExact, libscip), Cvoid, (Ptr{SCIP_RELAX},), relax) end function SCIPrelaxGetName(relax) @@ -59751,57 +24193,27 @@ function SCIPrelaxGetNCalls(relax) end function SCIPrelaxGetNCutoffs(relax) - ccall( - (:SCIPrelaxGetNCutoffs, libscip), - Clonglong, - (Ptr{SCIP_RELAX},), - relax, - ) + ccall((:SCIPrelaxGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) end function SCIPrelaxGetNImprovedLowerbound(relax) - ccall( - (:SCIPrelaxGetNImprovedLowerbound, libscip), - Clonglong, - (Ptr{SCIP_RELAX},), - relax, - ) + ccall((:SCIPrelaxGetNImprovedLowerbound, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) end function SCIPrelaxGetImprovedLowerboundTime(relax) - ccall( - (:SCIPrelaxGetImprovedLowerboundTime, libscip), - Cdouble, - (Ptr{SCIP_RELAX},), - relax, - ) + ccall((:SCIPrelaxGetImprovedLowerboundTime, libscip), Cdouble, (Ptr{SCIP_RELAX},), relax) end function SCIPrelaxGetNAddedConss(relax) - ccall( - (:SCIPrelaxGetNAddedConss, libscip), - Clonglong, - (Ptr{SCIP_RELAX},), - relax, - ) + ccall((:SCIPrelaxGetNAddedConss, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) end function SCIPrelaxGetNReducedDomains(relax) - ccall( - (:SCIPrelaxGetNReducedDomains, libscip), - Clonglong, - (Ptr{SCIP_RELAX},), - relax, - ) + ccall((:SCIPrelaxGetNReducedDomains, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) end function SCIPrelaxGetNSeparatedCuts(relax) - ccall( - (:SCIPrelaxGetNSeparatedCuts, libscip), - Clonglong, - (Ptr{SCIP_RELAX},), - relax, - ) + ccall((:SCIPrelaxGetNSeparatedCuts, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) end function SCIPrelaxIsInitialized(relax) @@ -59813,162 +24225,51 @@ function SCIPrelaxMarkUnsolved(relax) end function SCIPreoptnodeGetNVars(reoptnode) - ccall( - (:SCIPreoptnodeGetNVars, libscip), - Cint, - (Ptr{SCIP_REOPTNODE},), - reoptnode, - ) + ccall((:SCIPreoptnodeGetNVars, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) end function SCIPreoptnodeGetNConss(reoptnode) - ccall( - (:SCIPreoptnodeGetNConss, libscip), - Cint, - (Ptr{SCIP_REOPTNODE},), - reoptnode, - ) + ccall((:SCIPreoptnodeGetNConss, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) end function SCIPreoptnodeGetNDualBoundChgs(reoptnode) - ccall( - (:SCIPreoptnodeGetNDualBoundChgs, libscip), - Cint, - (Ptr{SCIP_REOPTNODE},), - reoptnode, - ) + ccall((:SCIPreoptnodeGetNDualBoundChgs, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) end function SCIPreoptnodeGetNChildren(reoptnode) - ccall( - (:SCIPreoptnodeGetNChildren, libscip), - Cint, - (Ptr{SCIP_REOPTNODE},), - reoptnode, - ) + ccall((:SCIPreoptnodeGetNChildren, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) end function SCIPreoptnodeGetLowerbound(reoptnode) - ccall( - (:SCIPreoptnodeGetLowerbound, libscip), - Cdouble, - (Ptr{SCIP_REOPTNODE},), - 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, - ) + ccall((:SCIPreoptnodeGetType, libscip), SCIP_REOPTTYPE, (Ptr{SCIP_REOPTNODE},), reoptnode) +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}, Cuint), - reoptnode, - parentid, - ) + ccall((:SCIPreoptnodeSetParentID, libscip), Cvoid, (Ptr{SCIP_REOPTNODE}, Cuint), reoptnode, parentid) end function SCIPreoptGetNRestartsGlobal(reopt) - ccall( - (:SCIPreoptGetNRestartsGlobal, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetNRestartsGlobal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPreoptGetNRestartsLocal(reopt) - ccall( - (:SCIPreoptGetNRestartsLocal, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetNRestartsLocal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPreoptGetNTotalRestartsLocal(reopt) - ccall( - (:SCIPreoptGetNTotalRestartsLocal, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetNTotalRestartsLocal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPreoptGetFirstRestarts(reopt) - ccall( - (:SCIPreoptGetFirstRestarts, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetFirstRestarts, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPreoptGetLastRestarts(reopt) @@ -59980,12 +24281,7 @@ function SCIPreoptGetNFeasNodes(reopt) end function SCIPreoptGetNTotalFeasNodes(reopt) - ccall( - (:SCIPreoptGetNTotalFeasNodes, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetNTotalFeasNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPreoptGetNPrunedNodes(reopt) @@ -59993,30 +24289,15 @@ function SCIPreoptGetNPrunedNodes(reopt) end function SCIPreoptGetNTotalPrunedNodes(reopt) - ccall( - (:SCIPreoptGetNTotalPrunedNodes, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetNTotalPrunedNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPreoptGetNCutoffReoptnodes(reopt) - ccall( - (:SCIPreoptGetNCutoffReoptnodes, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetNCutoffReoptnodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPreoptGetNTotalCutoffReoptnodes(reopt) - ccall( - (:SCIPreoptGetNTotalCutoffReoptnodes, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetNTotalCutoffReoptnodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPreoptGetNInfNodes(reopt) @@ -60024,51 +24305,23 @@ function SCIPreoptGetNInfNodes(reopt) end function SCIPreoptGetNTotalInfNodes(reopt) - ccall( - (:SCIPreoptGetNTotalInfNodes, libscip), - Cint, - (Ptr{SCIP_REOPT},), - reopt, - ) + ccall((:SCIPreoptGetNTotalInfNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) end function SCIPsepaComp(elem1, elem2) - ccall( - (:SCIPsepaComp, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - 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, - ) + ccall((:SCIPsepaCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) end function SCIPsepaGetData(sepa) - ccall( - (:SCIPsepaGetData, libscip), - Ptr{SCIP_SEPADATA}, - (Ptr{SCIP_SEPA},), - 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, - ) + ccall((:SCIPsepaSetData, libscip), Cvoid, (Ptr{SCIP_SEPA}, Ptr{SCIP_SEPADATA}), sepa, sepadata) end function SCIPsepaGetName(sepa) @@ -60088,13 +24341,11 @@ function SCIPsepaGetFreq(sepa) end function SCIPsepaSetFreq(sepa, freq) - ccall( - (:SCIPsepaSetFreq, libscip), - Cvoid, - (Ptr{SCIP_SEPA}, Cint), - sepa, - freq, - ) + ccall((:SCIPsepaSetFreq, libscip), Cvoid, (Ptr{SCIP_SEPA}, Cint), sepa, freq) +end + +function SCIPsepaMarkExact(sepa) + ccall((:SCIPsepaMarkExact, libscip), Cvoid, (Ptr{SCIP_SEPA},), sepa) end function SCIPsepaGetMaxbounddist(sepa) @@ -60117,6 +24368,10 @@ function SCIPsepaGetNCalls(sepa) ccall((:SCIPsepaGetNCalls, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) end +function SCIPsepaGetNRootCalls(sepa) + ccall((:SCIPsepaGetNRootCalls, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + function SCIPsepaGetNCallsAtNode(sepa) ccall((:SCIPsepaGetNCallsAtNode, libscip), Cint, (Ptr{SCIP_SEPA},), sepa) end @@ -60129,40 +24384,40 @@ function SCIPsepaGetNCutsFound(sepa) ccall((:SCIPsepaGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) end +function SCIPsepaGetNCutsAdded(sepa) + ccall((:SCIPsepaGetNCutsAdded, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCutsAddedViaPool(sepa) + ccall((:SCIPsepaGetNCutsAddedViaPool, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCutsAddedDirect(sepa) + ccall((:SCIPsepaGetNCutsAddedDirect, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + function SCIPsepaGetNCutsApplied(sepa) - ccall( - (:SCIPsepaGetNCutsApplied, libscip), - Clonglong, - (Ptr{SCIP_SEPA},), - sepa, - ) + ccall((:SCIPsepaGetNCutsApplied, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCutsAppliedViaPool(sepa) + ccall((:SCIPsepaGetNCutsAppliedViaPool, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) +end + +function SCIPsepaGetNCutsAppliedDirect(sepa) + ccall((:SCIPsepaGetNCutsAppliedDirect, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) end function SCIPsepaGetNCutsFoundAtNode(sepa) - ccall( - (:SCIPsepaGetNCutsFoundAtNode, libscip), - Clonglong, - (Ptr{SCIP_SEPA},), - sepa, - ) + ccall((:SCIPsepaGetNCutsFoundAtNode, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) end function SCIPsepaGetNConssFound(sepa) - ccall( - (:SCIPsepaGetNConssFound, libscip), - Clonglong, - (Ptr{SCIP_SEPA},), - sepa, - ) + ccall((:SCIPsepaGetNConssFound, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) end function SCIPsepaGetNDomredsFound(sepa) - ccall( - (:SCIPsepaGetNDomredsFound, libscip), - Clonglong, - (Ptr{SCIP_SEPA},), - sepa, - ) + ccall((:SCIPsepaGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) end function SCIPsepaIsDelayed(sepa) @@ -60186,12 +24441,7 @@ function SCIPsepaIsParentsepa(sepa) end function SCIPsepaGetParentsepa(sepa) - ccall( - (:SCIPsepaGetParentsepa, libscip), - Ptr{SCIP_SEPA}, - (Ptr{SCIP_SEPA},), - sepa, - ) + ccall((:SCIPsepaGetParentsepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP_SEPA},), sepa) end function SCIPsolGetOrigin(sol) @@ -60202,6 +24452,10 @@ function SCIPsolIsOriginal(sol) ccall((:SCIPsolIsOriginal, libscip), Cuint, (Ptr{SCIP_SOL},), sol) end +function SCIPsolIsExact(sol) + ccall((:SCIPsolIsExact, libscip), Cuint, (Ptr{SCIP_SOL},), sol) +end + function SCIPsolIsPartial(sol) ccall((:SCIPsolIsPartial, libscip), Cuint, (Ptr{SCIP_SOL},), sol) end @@ -60210,6 +24464,10 @@ function SCIPsolGetOrigObj(sol) ccall((:SCIPsolGetOrigObj, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end +function SCIPsolOrigAddObjvalExact(sol, addval) + ccall((:SCIPsolOrigAddObjvalExact, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), sol, addval) +end + function SCIPsolGetTime(sol) ccall((:SCIPsolGetTime, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end @@ -60239,23 +24497,11 @@ function SCIPsolGetRelax(sol) end function SCIPsolSetHeur(sol, heur) - ccall( - (:SCIPsolSetHeur, libscip), - Cvoid, - (Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}), - sol, - heur, - ) + ccall((:SCIPsolSetHeur, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}), sol, heur) end function SCIPsolSetRelax(sol, relax) - ccall( - (:SCIPsolSetRelax, libscip), - Cvoid, - (Ptr{SCIP_SOL}, Ptr{SCIP_RELAX}), - sol, - relax, - ) + ccall((:SCIPsolSetRelax, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_RELAX}), sol, relax) end function SCIPsolSetLPRelaxation(sol) @@ -60275,85 +24521,39 @@ function SCIPsolGetIndex(sol) end function SCIPsolGetAbsBoundViolation(sol) - ccall( - (:SCIPsolGetAbsBoundViolation, libscip), - Cdouble, - (Ptr{SCIP_SOL},), - sol, - ) + ccall((:SCIPsolGetAbsBoundViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end function SCIPsolGetRelBoundViolation(sol) - ccall( - (:SCIPsolGetRelBoundViolation, libscip), - Cdouble, - (Ptr{SCIP_SOL},), - sol, - ) + ccall((:SCIPsolGetRelBoundViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end function SCIPsolGetAbsIntegralityViolation(sol) - ccall( - (:SCIPsolGetAbsIntegralityViolation, libscip), - Cdouble, - (Ptr{SCIP_SOL},), - sol, - ) + ccall((:SCIPsolGetAbsIntegralityViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end function SCIPsolGetAbsLPRowViolation(sol) - ccall( - (:SCIPsolGetAbsLPRowViolation, libscip), - Cdouble, - (Ptr{SCIP_SOL},), - sol, - ) + ccall((:SCIPsolGetAbsLPRowViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end function SCIPsolGetRelLPRowViolation(sol) - ccall( - (:SCIPsolGetRelLPRowViolation, libscip), - Cdouble, - (Ptr{SCIP_SOL},), - sol, - ) + ccall((:SCIPsolGetRelLPRowViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end function SCIPsolGetAbsConsViolation(sol) - ccall( - (:SCIPsolGetAbsConsViolation, libscip), - Cdouble, - (Ptr{SCIP_SOL},), - sol, - ) + ccall((:SCIPsolGetAbsConsViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end function SCIPsolGetRelConsViolation(sol) - ccall( - (:SCIPsolGetRelConsViolation, libscip), - Cdouble, - (Ptr{SCIP_SOL},), - sol, - ) + ccall((:SCIPsolGetRelConsViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) end function SCIPtableGetData(table) - ccall( - (:SCIPtableGetData, libscip), - Ptr{SCIP_TABLEDATA}, - (Ptr{SCIP_TABLE},), - 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, - ) + ccall((:SCIPtableSetData, libscip), Cvoid, (Ptr{SCIP_TABLE}, Ptr{SCIP_TABLEDATA}), table, tabledata) end function SCIPtableGetName(table) @@ -60369,12 +24569,7 @@ function SCIPtableGetPosition(table) end function SCIPtableGetEarliestStage(table) - ccall( - (:SCIPtableGetEarliestStage, libscip), - SCIP_STAGE, - (Ptr{SCIP_TABLE},), - table, - ) + ccall((:SCIPtableGetEarliestStage, libscip), SCIP_STAGE, (Ptr{SCIP_TABLE},), table) end function SCIPtableIsActive(table) @@ -60386,167 +24581,35 @@ function SCIPtableIsInitialized(table) end 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, - ) + 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{Libc.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, - ) + ccall((:SCIPnodePrintAncestorBranchings, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{Libc.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), - Cuint, - (Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), - node1, - node2, - ) + ccall((:SCIPnodesSharePath, libscip), Cuint, (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, - ) + ccall((:SCIPnodesGetCommonAncestor, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), node1, node2) end function SCIPnodeGetType(node) @@ -60565,17 +24628,16 @@ function SCIPnodeGetLowerbound(node) ccall((:SCIPnodeGetLowerbound, libscip), Cdouble, (Ptr{SCIP_NODE},), node) end +function SCIPnodeGetLowerboundExact(node) + ccall((:SCIPnodeGetLowerboundExact, libscip), Ptr{SCIP_RATIONAL}, (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, - ) + ccall((:SCIPnodeGetReopttype, libscip), SCIP_REOPTTYPE, (Ptr{SCIP_NODE},), node) end function SCIPnodeGetReoptID(node) @@ -60583,65 +24645,27 @@ function SCIPnodeGetReoptID(node) end function SCIPnodeSetReopttype(node, reopttype) - ccall( - (:SCIPnodeSetReopttype, libscip), - Cvoid, - (Ptr{SCIP_NODE}, SCIP_REOPTTYPE), - 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}, Cuint), - node, - id, - ) + ccall((:SCIPnodeSetReoptID, libscip), Cvoid, (Ptr{SCIP_NODE}, Cuint), 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, - ) + 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, - ) + ccall((:SCIPnodeGetDomchg, libscip), Ptr{SCIP_DOMCHG}, (Ptr{SCIP_NODE},), node) end function SCIPnodeGetParent(node) - ccall( - (:SCIPnodeGetParent, libscip), - Ptr{SCIP_NODE}, - (Ptr{SCIP_NODE},), - 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, - ) + ccall((:SCIPnodeGetAddedConss, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), node, addedconss, naddedconss, addedconsssize) end function SCIPnodeGetNAddedConss(node) @@ -60657,12 +24681,7 @@ function SCIPnodeIsPropagatedAgain(node) end function SCIPnodeGetConssetchg(node) - ccall( - (:SCIPnodeGetConssetchg, libscip), - Ptr{SCIP_CONSSETCHG}, - (Ptr{SCIP_NODE},), - node, - ) + ccall((:SCIPnodeGetConssetchg, libscip), Ptr{SCIP_CONSSETCHG}, (Ptr{SCIP_NODE},), node) end function SCIPvarGetNLocksDown(var) @@ -60674,23 +24693,11 @@ function SCIPvarGetNLocksUp(var) end function SCIPvarGetNLocksUpType(var, locktype) - ccall( - (:SCIPvarGetNLocksUpType, libscip), - Cint, - (Ptr{SCIP_VAR}, SCIP_LOCKTYPE), - 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, - ) + ccall((:SCIPvarGetNLocksDownType, libscip), Cint, (Ptr{SCIP_VAR}, SCIP_LOCKTYPE), var, locktype) end function SCIPvarMayRoundDown(var) @@ -60702,33 +24709,15 @@ function SCIPvarMayRoundUp(var) end function SCIPvarCompareActiveAndNegated(var1, var2) - ccall( - (:SCIPvarCompareActiveAndNegated, libscip), - Cint, - (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), - 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, - ) + 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, - ) + ccall((:SCIPvarCompare, libscip), Cint, (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), var1, var2) end function SCIPvarComp(elem1, elem2) @@ -60736,54 +24725,23 @@ function SCIPvarComp(elem1, elem2) end function SCIPvarCompObj(elem1, elem2) - ccall( - (:SCIPvarCompObj, libscip), - Cint, - (Ptr{Cvoid}, Ptr{Cvoid}), - 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, - ) + ccall((:SCIPvarGetHashkey, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Ptr{Cvoid}), userptr, elem) end function SCIPvarIsHashkeyEq(userptr, key1, key2) - ccall( - (:SCIPvarIsHashkeyEq, libscip), - Cuint, - (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), - userptr, - key1, - key2, - ) + ccall((:SCIPvarIsHashkeyEq, libscip), Cuint, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), userptr, key1, key2) end function SCIPvarGetHashkeyVal(userptr, key) - ccall( - (:SCIPvarGetHashkeyVal, libscip), - UInt64, - (Ptr{Cvoid}, Ptr{Cvoid}), - 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, - ) + ccall((:SCIPvarsGetProbvar, libscip), Cvoid, (Ptr{Ptr{SCIP_VAR}}, Cint), vars, nvars) end function SCIPvarGetProbvar(var) @@ -60791,57 +24749,31 @@ function SCIPvarGetProbvar(var) end function SCIPvarsGetProbvarBinary(vars, negatedarr, nvars) - ccall( - (:SCIPvarsGetProbvarBinary, libscip), - SCIP_RETCODE, - (Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cuint}}, Cint), - vars, - negatedarr, - nvars, - ) + ccall((:SCIPvarsGetProbvarBinary, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cuint}}, Cint), vars, negatedarr, nvars) end function SCIPvarGetProbvarBinary(var, negated) - ccall( - (:SCIPvarGetProbvarBinary, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), - var, - negated, - ) + ccall((:SCIPvarGetProbvarBinary, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), 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, - ) + ccall((:SCIPvarGetProbvarBound, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}), var, bound, boundtype) +end + +function SCIPvarGetProbvarBoundExact(var, bound, boundtype) + ccall((:SCIPvarGetProbvarBoundExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, 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, - ) + 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, - ) + ccall((:SCIPvarGetOrigvarSum, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), var, scalar, constant) +end + +function SCIPvarGetOrigvarSumExact(var, scalar, constant) + ccall((:SCIPvarGetOrigvarSumExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), var, scalar, constant) end function SCIPvarIsTransformedOrigvar(var) @@ -60849,163 +24781,63 @@ function SCIPvarIsTransformedOrigvar(var) end function SCIPvarGetNBranchings(var, dir) - ccall( - (:SCIPvarGetNBranchings, libscip), - Clonglong, - (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), - 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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, - ) + ccall((:SCIPvarGetAvgBranchdepthCurrentRun, libscip), Cdouble, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), var, dir) end function SCIPvarHasImplic(var, varfixing, implvar, impltype) - ccall( - (:SCIPvarHasImplic, libscip), - Cuint, - (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE), - var, - varfixing, - implvar, - impltype, - ) + ccall((:SCIPvarHasImplic, libscip), Cuint, (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE), var, varfixing, implvar, impltype) end function SCIPvarHasBinaryImplic(var, varfixing, implvar, implvarfixing) - ccall( - (:SCIPvarHasBinaryImplic, libscip), - Cuint, - (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint), - var, - varfixing, - implvar, - implvarfixing, - ) + ccall((:SCIPvarHasBinaryImplic, libscip), Cuint, (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint), var, varfixing, implvar, implvarfixing) end function SCIPvarGetImplicVarBounds(var, varfixing, implvar, lb, ub) - ccall( - (:SCIPvarGetImplicVarBounds, libscip), - Cvoid, - (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Ptr{Cdouble}, Ptr{Cdouble}), - var, - varfixing, - implvar, - lb, - ub, - ) + ccall((:SCIPvarGetImplicVarBounds, libscip), Cvoid, (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Ptr{Cdouble}, Ptr{Cdouble}), var, varfixing, implvar, lb, ub) end function SCIPvarsHaveCommonClique(var1, value1, var2, value2, regardimplics) - ccall( - (:SCIPvarsHaveCommonClique, libscip), - Cuint, - (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint, Cuint), - var1, - value1, - var2, - value2, - regardimplics, - ) + ccall((:SCIPvarsHaveCommonClique, libscip), Cuint, (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint, Cuint), var1, value1, var2, value2, regardimplics) end function SCIPvarGetAggregatedObj(var, aggrobj) - ccall( - (:SCIPvarGetAggregatedObj, libscip), - SCIP_RETCODE, - (Ptr{SCIP_VAR}, Ptr{Cdouble}), - 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}, Cuint), - var, - initial, - ) + ccall((:SCIPvarSetInitial, libscip), SCIP_RETCODE, (Ptr{SCIP_VAR}, Cuint), var, initial) end function SCIPvarSetRemovable(var, removable) - ccall( - (:SCIPvarSetRemovable, libscip), - SCIP_RETCODE, - (Ptr{SCIP_VAR}, Cuint), - var, - removable, - ) + ccall((:SCIPvarSetRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP_VAR}, Cuint), var, removable) end function SCIPvarGetName(var) @@ -61021,59 +24853,37 @@ function SCIPvarGetData(var) end function SCIPvarSetData(var, vardata) - ccall( - (:SCIPvarSetData, libscip), - Cvoid, - (Ptr{SCIP_VAR}, Ptr{SCIP_VARDATA}), - 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, - ) + 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, - ) + 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, - ) + 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, - ) + 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 SCIPvarGetStatusExact(var) + ccall((:SCIPvarGetStatusExact, libscip), SCIP_VARSTATUS, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsExact(var) + ccall((:SCIPvarIsExact, libscip), Cuint, (Ptr{SCIP_VAR},), var) +end + function SCIPvarIsOriginal(var) ccall((:SCIPvarIsOriginal, libscip), Cuint, (Ptr{SCIP_VAR},), var) end @@ -61090,6 +24900,10 @@ function SCIPvarGetType(var) ccall((:SCIPvarGetType, libscip), SCIP_VARTYPE, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetImplType(var) + ccall((:SCIPvarGetImplType, libscip), SCIP_IMPLINTTYPE, (Ptr{SCIP_VAR},), var) +end + function SCIPvarIsBinary(var) ccall((:SCIPvarIsBinary, libscip), Cuint, (Ptr{SCIP_VAR},), var) end @@ -61098,6 +24912,14 @@ function SCIPvarIsIntegral(var) ccall((:SCIPvarIsIntegral, libscip), Cuint, (Ptr{SCIP_VAR},), var) end +function SCIPvarIsImpliedIntegral(var) + ccall((:SCIPvarIsImpliedIntegral, libscip), Cuint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarIsNonimpliedIntegral(var) + ccall((:SCIPvarIsNonimpliedIntegral, libscip), Cuint, (Ptr{SCIP_VAR},), var) +end + function SCIPvarIsInitial(var) ccall((:SCIPvarIsInitial, libscip), Cuint, (Ptr{SCIP_VAR},), var) end @@ -61123,12 +24945,7 @@ function SCIPvarIsDeletable(var) end function SCIPvarMarkDeleteGlobalStructures(var) - ccall( - (:SCIPvarMarkDeleteGlobalStructures, libscip), - Cvoid, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarMarkDeleteGlobalStructures, libscip), Cvoid, (Ptr{SCIP_VAR},), var) end function SCIPvarIsActive(var) @@ -61143,6 +24960,38 @@ function SCIPvarGetProbindex(var) ccall((:SCIPvarGetProbindex, libscip), Cint, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetCertificateIndex(var) + ccall((:SCIPvarGetCertificateIndex, libscip), Cint, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarSetCertificateIndex(var, certidx) + ccall((:SCIPvarSetCertificateIndex, libscip), Cvoid, (Ptr{SCIP_VAR}, Cint), var, certidx) +end + +function SCIPvarSetUbCertificateIndexGlobal(var, certidx) + ccall((:SCIPvarSetUbCertificateIndexGlobal, libscip), Cvoid, (Ptr{SCIP_VAR}, Clonglong), var, certidx) +end + +function SCIPvarSetLbCertificateIndexGlobal(var, certidx) + ccall((:SCIPvarSetLbCertificateIndexGlobal, libscip), Cvoid, (Ptr{SCIP_VAR}, Clonglong), var, certidx) +end + +function SCIPvarGetLbCertificateIndexLocal(var) + ccall((:SCIPvarGetLbCertificateIndexLocal, libscip), Clonglong, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetUbCertificateIndexLocal(var) + ccall((:SCIPvarGetUbCertificateIndexLocal, libscip), Clonglong, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetLbCertificateIndexGlobal(var) + ccall((:SCIPvarGetLbCertificateIndexGlobal, libscip), Clonglong, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetUbCertificateIndexGlobal(var) + ccall((:SCIPvarGetUbCertificateIndexGlobal, libscip), Clonglong, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetTransVar(var) ccall((:SCIPvarGetTransVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), var) end @@ -61151,10 +25000,22 @@ function SCIPvarGetCol(var) ccall((:SCIPvarGetCol, libscip), Ptr{SCIP_COL}, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetColExact(var) + ccall((:SCIPvarGetColExact, libscip), Ptr{SCIP_COLEXACT}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarIsInLP(var) ccall((:SCIPvarIsInLP, libscip), Cuint, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetMinAggrCoef(var) + ccall((:SCIPvarGetMinAggrCoef, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetMaxAggrCoef(var) + ccall((:SCIPvarGetMaxAggrCoef, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetAggrVar(var) ccall((:SCIPvarGetAggrVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), var) end @@ -61163,72 +25024,66 @@ function SCIPvarGetAggrScalar(var) ccall((:SCIPvarGetAggrScalar, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetAggrScalarExact(var) + ccall((:SCIPvarGetAggrScalarExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetAggrConstant(var) ccall((:SCIPvarGetAggrConstant, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetAggrConstantExact(var) + ccall((:SCIPvarGetAggrConstantExact, libscip), Ptr{SCIP_RATIONAL}, (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, - ) + ccall((:SCIPvarGetMultaggrVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetMultaggrScalars(var) - ccall( - (:SCIPvarGetMultaggrScalars, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetMultaggrScalars, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetMultaggrScalarsExact(var) + ccall((:SCIPvarGetMultaggrScalarsExact, libscip), Ptr{Ptr{SCIP_RATIONAL}}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetMultaggrConstant(var) - ccall( - (:SCIPvarGetMultaggrConstant, libscip), - Cdouble, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetMultaggrConstant, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetMultaggrConstantExact(var) + ccall((:SCIPvarGetMultaggrConstantExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetNegatedVar(var) - ccall( - (:SCIPvarGetNegatedVar, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_VAR},), - 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, - ) + ccall((:SCIPvarGetNegationVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetNegationConstant(var) - ccall( - (:SCIPvarGetNegationConstant, libscip), - Cdouble, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetNegationConstant, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end function SCIPvarGetObj(var) ccall((:SCIPvarGetObj, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetObjExact(var) + ccall((:SCIPvarGetObjExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetObjInterval(var) + ccall((:SCIPvarGetObjInterval, libscip), SCIP_INTERVAL, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetUnchangedObj(var) ccall((:SCIPvarGetUnchangedObj, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end @@ -61237,90 +25092,108 @@ function SCIPvarGetLbOriginal(var) ccall((:SCIPvarGetLbOriginal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetLbOriginalExact(var) + ccall((:SCIPvarGetLbOriginalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetUbOriginal(var) ccall((:SCIPvarGetUbOriginal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetUbOriginalExact(var) + ccall((:SCIPvarGetUbOriginalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetHolelistOriginal(var) - ccall( - (:SCIPvarGetHolelistOriginal, libscip), - Ptr{SCIP_HOLELIST}, - (Ptr{SCIP_VAR},), - 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 SCIPvarGetLbGlobalExact(var) + ccall((:SCIPvarGetLbGlobalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetUbGlobal(var) ccall((:SCIPvarGetUbGlobal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetUbGlobalExact(var) + ccall((:SCIPvarGetUbGlobalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetHolelistGlobal(var) - ccall( - (:SCIPvarGetHolelistGlobal, libscip), - Ptr{SCIP_HOLELIST}, - (Ptr{SCIP_VAR},), - 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 SCIPvarGetBestBoundGlobalExact(var) + ccall((:SCIPvarGetBestBoundGlobalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetWorstBoundGlobal(var) - ccall( - (:SCIPvarGetWorstBoundGlobal, libscip), - Cdouble, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetWorstBoundGlobal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetWorstBoundGlobalExact(var) + ccall((:SCIPvarGetWorstBoundGlobalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetLbLocal(var) ccall((:SCIPvarGetLbLocal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetLbLocalExact(var) + ccall((:SCIPvarGetLbLocalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetUbLocal(var) ccall((:SCIPvarGetUbLocal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetUbLocalExact(var) + ccall((:SCIPvarGetUbLocalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetHolelistLocal(var) - ccall( - (:SCIPvarGetHolelistLocal, libscip), - Ptr{SCIP_HOLELIST}, - (Ptr{SCIP_VAR},), - 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 SCIPvarGetBestBoundLocalExact(var) + ccall((:SCIPvarGetBestBoundLocalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetWorstBoundLocal(var) ccall((:SCIPvarGetWorstBoundLocal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetWorstBoundLocalExact(var) + ccall((:SCIPvarGetWorstBoundLocalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetBestBoundType(var) - ccall( - (:SCIPvarGetBestBoundType, libscip), - SCIP_BOUNDTYPE, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetBestBoundType, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetBestBoundTypeExact(var) + ccall((:SCIPvarGetBestBoundTypeExact, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) end function SCIPvarGetWorstBoundType(var) - ccall( - (:SCIPvarGetWorstBoundType, libscip), - SCIP_BOUNDTYPE, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetWorstBoundType, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) +end + +function SCIPvarGetWorstBoundTypeExact(var) + ccall((:SCIPvarGetWorstBoundTypeExact, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) end function SCIPvarGetLbLazy(var) @@ -61340,12 +25213,7 @@ function SCIPvarGetBranchPriority(var) end function SCIPvarGetBranchDirection(var) - ccall( - (:SCIPvarGetBranchDirection, libscip), - SCIP_BRANCHDIR, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetBranchDirection, libscip), SCIP_BRANCHDIR, (Ptr{SCIP_VAR},), var) end function SCIPvarGetNVlbs(var) @@ -61353,12 +25221,7 @@ function SCIPvarGetNVlbs(var) end function SCIPvarGetVlbVars(var) - ccall( - (:SCIPvarGetVlbVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetVlbVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetVlbCoefs(var) @@ -61366,12 +25229,7 @@ function SCIPvarGetVlbCoefs(var) end function SCIPvarGetVlbConstants(var) - ccall( - (:SCIPvarGetVlbConstants, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetVlbConstants, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetNVubs(var) @@ -61379,12 +25237,7 @@ function SCIPvarGetNVubs(var) end function SCIPvarGetVubVars(var) - ccall( - (:SCIPvarGetVubVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetVubVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetVubCoefs(var) @@ -61392,100 +25245,51 @@ function SCIPvarGetVubCoefs(var) end function SCIPvarGetVubConstants(var) - ccall( - (:SCIPvarGetVubConstants, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetVubConstants, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetNImpls(var, varfixing) - ccall( - (:SCIPvarGetNImpls, libscip), - Cint, - (Ptr{SCIP_VAR}, Cuint), - var, - varfixing, - ) + ccall((:SCIPvarGetNImpls, libscip), Cint, (Ptr{SCIP_VAR}, Cuint), var, varfixing) end function SCIPvarGetImplVars(var, varfixing) - ccall( - (:SCIPvarGetImplVars, libscip), - Ptr{Ptr{SCIP_VAR}}, - (Ptr{SCIP_VAR}, Cuint), - var, - varfixing, - ) + ccall((:SCIPvarGetImplVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) end function SCIPvarGetImplTypes(var, varfixing) - ccall( - (:SCIPvarGetImplTypes, libscip), - Ptr{SCIP_BOUNDTYPE}, - (Ptr{SCIP_VAR}, Cuint), - var, - varfixing, - ) + ccall((:SCIPvarGetImplTypes, libscip), Ptr{SCIP_BOUNDTYPE}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) end function SCIPvarGetImplBounds(var, varfixing) - ccall( - (:SCIPvarGetImplBounds, libscip), - Ptr{Cdouble}, - (Ptr{SCIP_VAR}, Cuint), - var, - varfixing, - ) + ccall((:SCIPvarGetImplBounds, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) end function SCIPvarGetImplIds(var, varfixing) - ccall( - (:SCIPvarGetImplIds, libscip), - Ptr{Cint}, - (Ptr{SCIP_VAR}, Cuint), - var, - varfixing, - ) + ccall((:SCIPvarGetImplIds, libscip), Ptr{Cint}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) end function SCIPvarGetNCliques(var, varfixing) - ccall( - (:SCIPvarGetNCliques, libscip), - Cint, - (Ptr{SCIP_VAR}, Cuint), - var, - varfixing, - ) + ccall((:SCIPvarGetNCliques, libscip), Cint, (Ptr{SCIP_VAR}, Cuint), var, varfixing) end function SCIPvarGetCliques(var, varfixing) - ccall( - (:SCIPvarGetCliques, libscip), - Ptr{Ptr{SCIP_CLIQUE}}, - (Ptr{SCIP_VAR}, Cuint), - var, - varfixing, - ) + ccall((:SCIPvarGetCliques, libscip), Ptr{Ptr{SCIP_CLIQUE}}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) end function SCIPvarGetLPSol(var) ccall((:SCIPvarGetLPSol, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetLPSolExact(var, res) + ccall((:SCIPvarGetLPSolExact, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), var, res) +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, - ) + ccall((:SCIPvarGetBdchgInfoLb, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Cint), var, pos) end function SCIPvarGetNBdchgInfosLb(var) @@ -61493,13 +25297,7 @@ function SCIPvarGetNBdchgInfosLb(var) end function SCIPvarGetBdchgInfoUb(var, pos) - ccall( - (:SCIPvarGetBdchgInfoUb, libscip), - Ptr{SCIP_BDCHGINFO}, - (Ptr{SCIP_VAR}, Cint), - var, - pos, - ) + ccall((:SCIPvarGetBdchgInfoUb, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Cint), var, pos) end function SCIPvarGetNBdchgInfosUb(var) @@ -61507,12 +25305,7 @@ function SCIPvarGetNBdchgInfosUb(var) end function SCIPvarGetValuehistory(var) - ccall( - (:SCIPvarGetValuehistory, libscip), - Ptr{SCIP_VALUEHISTORY}, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetValuehistory, libscip), Ptr{SCIP_VALUEHISTORY}, (Ptr{SCIP_VAR},), var) end function SCIPvarIsRelaxationOnly(var) @@ -61527,6 +25320,10 @@ function SCIPvarGetLPSol_rec(var) ccall((:SCIPvarGetLPSol_rec, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetLPSolExact_rec(var, res) + ccall((:SCIPvarGetLPSolExact_rec, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), var, res) +end + function SCIPvarGetNLPSol_rec(var) ccall((:SCIPvarGetNLPSol_rec, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end @@ -61535,14 +25332,16 @@ function SCIPvarGetPseudoSol(var) ccall((:SCIPvarGetPseudoSol, libscip), Cdouble, (Ptr{SCIP_VAR},), var) end +function SCIPvarGetPseudoSolExact(var) + ccall((:SCIPvarGetPseudoSolExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) +end + function SCIPvarGetSol(var, getlpval) - ccall( - (:SCIPvarGetSol, libscip), - Cdouble, - (Ptr{SCIP_VAR}, Cuint), - var, - getlpval, - ) + ccall((:SCIPvarGetSol, libscip), Cdouble, (Ptr{SCIP_VAR}, Cuint), var, getlpval) +end + +function SCIPvarGetSolExact(var, res, getlpval) + ccall((:SCIPvarGetSolExact, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Cuint), var, res, getlpval) end function SCIPvarGetRootSol(var) @@ -61558,24 +25357,11 @@ function SCIPvarGetBestRootRedcost(var) end function SCIPvarGetBestRootLPObjval(var) - ccall( - (:SCIPvarGetBestRootLPObjval, libscip), - Cdouble, - (Ptr{SCIP_VAR},), - 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, - ) + ccall((:SCIPvarSetBestRootSol, libscip), Cvoid, (Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), var, rootsol, rootredcost, rootlpobjval) end function SCIPvarGetAvgSol(var) @@ -61583,91 +25369,19 @@ function SCIPvarGetAvgSol(var) end function SCIPvarGetLbchgInfo(var, bdchgidx, after) - ccall( - (:SCIPvarGetLbchgInfo, libscip), - Ptr{SCIP_BDCHGINFO}, - (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), - var, - bdchgidx, - after, - ) + ccall((:SCIPvarGetLbchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), var, bdchgidx, after) end function SCIPvarGetUbchgInfo(var, bdchgidx, after) - ccall( - (:SCIPvarGetUbchgInfo, libscip), - Ptr{SCIP_BDCHGINFO}, - (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), - var, - bdchgidx, - after, - ) + ccall((:SCIPvarGetUbchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), var, bdchgidx, after) end function SCIPvarGetBdchgInfo(var, boundtype, bdchgidx, after) - ccall( - (:SCIPvarGetBdchgInfo, libscip), - Ptr{SCIP_BDCHGINFO}, - (Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cuint), - var, - boundtype, - bdchgidx, - after, - ) -end - -function SCIPvarGetLbAtIndex(var, bdchgidx, after) - ccall( - (:SCIPvarGetLbAtIndex, libscip), - Cdouble, - (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), - var, - bdchgidx, - after, - ) -end - -function SCIPvarGetUbAtIndex(var, bdchgidx, after) - ccall( - (:SCIPvarGetUbAtIndex, libscip), - Cdouble, - (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), - var, - bdchgidx, - after, - ) -end - -function SCIPvarGetBdAtIndex(var, boundtype, bdchgidx, after) - ccall( - (:SCIPvarGetBdAtIndex, libscip), - Cdouble, - (Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cuint), - var, - boundtype, - bdchgidx, - after, - ) -end - -function SCIPvarWasFixedAtIndex(var, bdchgidx, after) - ccall( - (:SCIPvarWasFixedAtIndex, libscip), - Cuint, - (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), - var, - bdchgidx, - after, - ) + ccall((:SCIPvarGetBdchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cuint), var, boundtype, bdchgidx, after) end function SCIPvarGetLastBdchgIndex(var) - ccall( - (:SCIPvarGetLastBdchgIndex, libscip), - Ptr{SCIP_BDCHGIDX}, - (Ptr{SCIP_VAR},), - var, - ) + ccall((:SCIPvarGetLastBdchgIndex, libscip), Ptr{SCIP_BDCHGIDX}, (Ptr{SCIP_VAR},), var) end function SCIPvarGetLastBdchgDepth(var) @@ -61675,301 +25389,139 @@ function SCIPvarGetLastBdchgDepth(var) end function SCIPvarWasFixedEarlier(var1, var2) - ccall( - (:SCIPvarWasFixedEarlier, libscip), - Cuint, - (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), - var1, - var2, - ) + ccall((:SCIPvarWasFixedEarlier, libscip), Cuint, (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), var1, var2) +end + +function SCIPvarsCountTypes(vars, nvars, nbinvars, nintvars, nbinimplvars, nintimplvars, ncontimplvars, ncontvars) + ccall((:SCIPvarsCountTypes, libscip), Cvoid, (Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), vars, nvars, nbinvars, nintvars, nbinimplvars, nintimplvars, ncontimplvars, ncontvars) end function SCIPbdchgidxIsEarlier(bdchgidx1, bdchgidx2) - ccall( - (:SCIPbdchgidxIsEarlier, libscip), - Cuint, - (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), - bdchgidx1, - bdchgidx2, - ) + ccall((:SCIPbdchgidxIsEarlier, libscip), Cuint, (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), bdchgidx1, bdchgidx2) end function SCIPbdchgidxIsEarlierNonNull(bdchgidx1, bdchgidx2) - ccall( - (:SCIPbdchgidxIsEarlierNonNull, libscip), - Cuint, - (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), - bdchgidx1, - bdchgidx2, - ) + ccall((:SCIPbdchgidxIsEarlierNonNull, libscip), Cuint, (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), bdchgidx1, bdchgidx2) end function SCIPbdchginfoGetOldbound(bdchginfo) - ccall( - (:SCIPbdchginfoGetOldbound, libscip), - Cdouble, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetOldbound, libscip), Cdouble, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetNewbound(bdchginfo) - ccall( - (:SCIPbdchginfoGetNewbound, libscip), - Cdouble, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetNewbound, libscip), Cdouble, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetVar(bdchginfo) - ccall( - (:SCIPbdchginfoGetVar, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetChgtype(bdchginfo) - ccall( - (:SCIPbdchginfoGetChgtype, libscip), - SCIP_BOUNDCHGTYPE, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetChgtype, libscip), SCIP_BOUNDCHGTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetBoundtype(bdchginfo) - ccall( - (:SCIPbdchginfoGetBoundtype, libscip), - SCIP_BOUNDTYPE, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetDepth(bdchginfo) - ccall( - (:SCIPbdchginfoGetDepth, libscip), - Cint, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetDepth, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetPos(bdchginfo) - ccall( - (:SCIPbdchginfoGetPos, libscip), - Cint, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetPos, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetIdx(bdchginfo) - ccall( - (:SCIPbdchginfoGetIdx, libscip), - Ptr{SCIP_BDCHGIDX}, - (Ptr{SCIP_BDCHGINFO},), - 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, - ) + ccall((:SCIPbdchginfoGetInferVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetInferCons(bdchginfo) - ccall( - (:SCIPbdchginfoGetInferCons, libscip), - Ptr{SCIP_CONS}, - (Ptr{SCIP_BDCHGINFO},), - 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, - ) + ccall((:SCIPbdchginfoGetInferProp, libscip), Ptr{SCIP_PROP}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetInferInfo(bdchginfo) - ccall( - (:SCIPbdchginfoGetInferInfo, libscip), - Cint, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetInferInfo, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoGetInferBoundtype(bdchginfo) - ccall( - (:SCIPbdchginfoGetInferBoundtype, libscip), - SCIP_BOUNDTYPE, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoGetInferBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoIsRedundant(bdchginfo) - ccall( - (:SCIPbdchginfoIsRedundant, libscip), - Cuint, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoIsRedundant, libscip), Cuint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoHasInferenceReason(bdchginfo) - ccall( - (:SCIPbdchginfoHasInferenceReason, libscip), - Cuint, - (Ptr{SCIP_BDCHGINFO},), - bdchginfo, - ) + ccall((:SCIPbdchginfoHasInferenceReason, libscip), Cuint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) end function SCIPbdchginfoIsTighter(bdchginfo1, bdchginfo2) - ccall( - (:SCIPbdchginfoIsTighter, libscip), - Cuint, - (Ptr{SCIP_BDCHGINFO}, Ptr{SCIP_BDCHGINFO}), - bdchginfo1, - bdchginfo2, - ) + ccall((:SCIPbdchginfoIsTighter, libscip), Cuint, (Ptr{SCIP_BDCHGINFO}, Ptr{SCIP_BDCHGINFO}), bdchginfo1, bdchginfo2) end function SCIPboundchgGetNewbound(boundchg) - ccall( - (:SCIPboundchgGetNewbound, libscip), - Cdouble, - (Ptr{SCIP_BOUNDCHG},), - boundchg, - ) + ccall((:SCIPboundchgGetNewbound, libscip), Cdouble, (Ptr{SCIP_BOUNDCHG},), boundchg) +end + +function SCIPboundchgGetLPSolVal(boundchg) + ccall((:SCIPboundchgGetLPSolVal, libscip), Cdouble, (Ptr{SCIP_BOUNDCHG},), boundchg) end function SCIPboundchgGetVar(boundchg) - ccall( - (:SCIPboundchgGetVar, libscip), - Ptr{SCIP_VAR}, - (Ptr{SCIP_BOUNDCHG},), - boundchg, - ) + ccall((:SCIPboundchgGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BOUNDCHG},), boundchg) end function SCIPboundchgGetBoundchgtype(boundchg) - ccall( - (:SCIPboundchgGetBoundchgtype, libscip), - SCIP_BOUNDCHGTYPE, - (Ptr{SCIP_BOUNDCHG},), - boundchg, - ) + ccall((:SCIPboundchgGetBoundchgtype, libscip), SCIP_BOUNDCHGTYPE, (Ptr{SCIP_BOUNDCHG},), boundchg) end function SCIPboundchgGetBoundtype(boundchg) - ccall( - (:SCIPboundchgGetBoundtype, libscip), - SCIP_BOUNDTYPE, - (Ptr{SCIP_BOUNDCHG},), - boundchg, - ) + ccall((:SCIPboundchgGetBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BOUNDCHG},), boundchg) end function SCIPboundchgIsRedundant(boundchg) - ccall( - (:SCIPboundchgIsRedundant, libscip), - Cuint, - (Ptr{SCIP_BOUNDCHG},), - boundchg, - ) + ccall((:SCIPboundchgIsRedundant, libscip), Cuint, (Ptr{SCIP_BOUNDCHG},), boundchg) end function SCIPdomchgGetNBoundchgs(domchg) - ccall( - (:SCIPdomchgGetNBoundchgs, libscip), - Cint, - (Ptr{SCIP_DOMCHG},), - 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, - ) + ccall((:SCIPdomchgGetBoundchg, libscip), Ptr{SCIP_BOUNDCHG}, (Ptr{SCIP_DOMCHG}, Cint), domchg, pos) end function SCIPholelistGetLeft(holelist) - ccall( - (:SCIPholelistGetLeft, libscip), - Cdouble, - (Ptr{SCIP_HOLELIST},), - holelist, - ) + ccall((:SCIPholelistGetLeft, libscip), Cdouble, (Ptr{SCIP_HOLELIST},), holelist) end function SCIPholelistGetRight(holelist) - ccall( - (:SCIPholelistGetRight, libscip), - Cdouble, - (Ptr{SCIP_HOLELIST},), - holelist, - ) + ccall((:SCIPholelistGetRight, libscip), Cdouble, (Ptr{SCIP_HOLELIST},), holelist) end function SCIPholelistGetNext(holelist) - ccall( - (:SCIPholelistGetNext, libscip), - Ptr{SCIP_HOLELIST}, - (Ptr{SCIP_HOLELIST},), - holelist, - ) + ccall((:SCIPholelistGetNext, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_HOLELIST},), holelist) end function BMSclearMemory_call(ptr, size) - ccall( - (:BMSclearMemory_call, libscip), - Cvoid, - (Ptr{Cvoid}, Csize_t), - ptr, - size, - ) + ccall((:BMSclearMemory_call, libscip), Cvoid, (Ptr{Cvoid}, Csize_t), ptr, size) end function BMScopyMemory_call(ptr, source, size) - ccall( - (:BMScopyMemory_call, libscip), - Cvoid, - (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), - ptr, - source, - size, - ) + ccall((:BMScopyMemory_call, libscip), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), ptr, source, size) end function BMSmoveMemory_call(ptr, source, size) - ccall( - (:BMSmoveMemory_call, libscip), - Cvoid, - (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), - ptr, - source, - size, - ) + ccall((:BMSmoveMemory_call, libscip), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), ptr, source, size) end function BMSgetPointerSize_call(ptr) @@ -61992,282 +25544,100 @@ const BMS_ChkMem = Cvoid const BMS_CHKMEM = BMS_ChkMem -function BMScreateChunkMemory_call( - size, - initchunksize, - garbagefactor, - filename, - line, -) - ccall( - (:BMScreateChunkMemory_call, libscip), - Ptr{BMS_CHKMEM}, - (Csize_t, Cint, Cint, Ptr{Cchar}, Cint), - size, - initchunksize, - garbagefactor, - filename, - line, - ) +function BMScreateChunkMemory_call(size, initchunksize, garbagefactor, filename, line) + ccall((:BMScreateChunkMemory_call, libscip), Ptr{BMS_CHKMEM}, (Csize_t, Cint, Cint, Ptr{Cchar}, Cint), size, initchunksize, garbagefactor, filename, line) end function BMSclearChunkMemory_call(chkmem, filename, line) - ccall( - (:BMSclearChunkMemory_call, libscip), - Cvoid, - (Ptr{BMS_CHKMEM}, Ptr{Cchar}, Cint), - chkmem, - filename, - line, - ) + ccall((:BMSclearChunkMemory_call, libscip), Cvoid, (Ptr{BMS_CHKMEM}, Ptr{Cchar}, Cint), chkmem, filename, line) end function BMSdestroyChunkMemory_call(chkmem, filename, line) - ccall( - (:BMSdestroyChunkMemory_call, libscip), - Cvoid, - (Ptr{Ptr{BMS_CHKMEM}}, Ptr{Cchar}, Cint), - chkmem, - filename, - line, - ) + ccall((:BMSdestroyChunkMemory_call, libscip), Cvoid, (Ptr{Ptr{BMS_CHKMEM}}, Ptr{Cchar}, Cint), chkmem, filename, line) end function BMSallocChunkMemory_call(chkmem, size, filename, line) - ccall( - (:BMSallocChunkMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_CHKMEM}, Csize_t, Ptr{Cchar}, Cint), - chkmem, - size, - filename, - line, - ) + ccall((:BMSallocChunkMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_CHKMEM}, Csize_t, Ptr{Cchar}, Cint), chkmem, size, filename, line) end function BMSduplicateChunkMemory_call(chkmem, source, size, filename, line) - ccall( - (:BMSduplicateChunkMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_CHKMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), - chkmem, - source, - size, - filename, - line, - ) + ccall((:BMSduplicateChunkMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_CHKMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), chkmem, source, size, filename, line) end function BMSfreeChunkMemory_call(chkmem, ptr, size, filename, line) - ccall( - (:BMSfreeChunkMemory_call, libscip), - Cvoid, - (Ptr{BMS_CHKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), - chkmem, - ptr, - size, - filename, - line, - ) + ccall((:BMSfreeChunkMemory_call, libscip), Cvoid, (Ptr{BMS_CHKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), chkmem, ptr, size, filename, line) end function BMSfreeChunkMemoryNull_call(chkmem, ptr, size, filename, line) - ccall( - (:BMSfreeChunkMemoryNull_call, libscip), - Cvoid, - (Ptr{BMS_CHKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), - chkmem, - ptr, - size, - filename, - line, - ) + ccall((:BMSfreeChunkMemoryNull_call, libscip), Cvoid, (Ptr{BMS_CHKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), chkmem, ptr, size, filename, line) end function BMSgarbagecollectChunkMemory_call(chkmem) - ccall( - (:BMSgarbagecollectChunkMemory_call, libscip), - Cvoid, - (Ptr{BMS_CHKMEM},), - chkmem, - ) + ccall((:BMSgarbagecollectChunkMemory_call, libscip), Cvoid, (Ptr{BMS_CHKMEM},), chkmem) end function BMSgetChunkMemoryUsed_call(chkmem) - ccall( - (:BMSgetChunkMemoryUsed_call, libscip), - Clonglong, - (Ptr{BMS_CHKMEM},), - chkmem, - ) + ccall((:BMSgetChunkMemoryUsed_call, libscip), Clonglong, (Ptr{BMS_CHKMEM},), chkmem) end function BMScreateBlockMemory_call(initchunksize, garbagefactor, filename, line) - ccall( - (:BMScreateBlockMemory_call, libscip), - Ptr{BMS_BLKMEM}, - (Cint, Cint, Ptr{Cchar}, Cint), - initchunksize, - garbagefactor, - filename, - line, - ) + ccall((:BMScreateBlockMemory_call, libscip), Ptr{BMS_BLKMEM}, (Cint, Cint, Ptr{Cchar}, Cint), initchunksize, garbagefactor, filename, line) end function BMSclearBlockMemory_call(blkmem, filename, line) - ccall( - (:BMSclearBlockMemory_call, libscip), - Cvoid, - (Ptr{BMS_BLKMEM}, Ptr{Cchar}, Cint), - blkmem, - filename, - line, - ) + ccall((:BMSclearBlockMemory_call, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Cchar}, Cint), blkmem, filename, line) end function BMSdestroyBlockMemory_call(blkmem, filename, line) - ccall( - (:BMSdestroyBlockMemory_call, libscip), - Cvoid, - (Ptr{Ptr{BMS_BLKMEM}}, Ptr{Cchar}, Cint), - blkmem, - filename, - line, - ) + ccall((:BMSdestroyBlockMemory_call, libscip), Cvoid, (Ptr{Ptr{BMS_BLKMEM}}, Ptr{Cchar}, Cint), blkmem, filename, line) end function BMSgarbagecollectBlockMemory_call(blkmem) - ccall( - (:BMSgarbagecollectBlockMemory_call, libscip), - Cvoid, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMSgarbagecollectBlockMemory_call, libscip), Cvoid, (Ptr{BMS_BLKMEM},), blkmem) end function BMSgetBlockMemoryAllocated_call(blkmem) - ccall( - (:BMSgetBlockMemoryAllocated_call, libscip), - Clonglong, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMSgetBlockMemoryAllocated_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) end function BMSgetBlockMemoryUsed_call(blkmem) - ccall( - (:BMSgetBlockMemoryUsed_call, libscip), - Clonglong, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMSgetBlockMemoryUsed_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) end function BMSgetBlockMemoryUnused_call(blkmem) - ccall( - (:BMSgetBlockMemoryUnused_call, libscip), - Clonglong, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMSgetBlockMemoryUnused_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) end function BMSgetBlockMemoryUsedMax_call(blkmem) - ccall( - (:BMSgetBlockMemoryUsedMax_call, libscip), - Clonglong, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMSgetBlockMemoryUsedMax_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) end function BMSgetBlockMemoryUnusedMax_call(blkmem) - ccall( - (:BMSgetBlockMemoryUnusedMax_call, libscip), - Clonglong, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMSgetBlockMemoryUnusedMax_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) end function BMSgetBlockMemoryAllocatedMax_call(blkmem) - ccall( - (:BMSgetBlockMemoryAllocatedMax_call, libscip), - Clonglong, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMSgetBlockMemoryAllocatedMax_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) end function BMSgetBlockPointerSize_call(blkmem, ptr) - ccall( - (:BMSgetBlockPointerSize_call, libscip), - Csize_t, - (Ptr{BMS_BLKMEM}, Ptr{Cvoid}), - blkmem, - ptr, - ) + ccall((:BMSgetBlockPointerSize_call, libscip), Csize_t, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}), blkmem, ptr) end function BMSdisplayBlockMemory_call(blkmem) - ccall( - (:BMSdisplayBlockMemory_call, libscip), - Cvoid, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMSdisplayBlockMemory_call, libscip), Cvoid, (Ptr{BMS_BLKMEM},), blkmem) end function BMScheckEmptyBlockMemory_call(blkmem) - ccall( - (:BMScheckEmptyBlockMemory_call, libscip), - Clonglong, - (Ptr{BMS_BLKMEM},), - blkmem, - ) + ccall((:BMScheckEmptyBlockMemory_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) end -function BMSreallocBufferMemory_call(buffer, ptr, size, filename, line) - ccall( - (:BMSreallocBufferMemory_call, libscip), - Ptr{Cvoid}, - (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), - buffer, - ptr, - size, - filename, - line, - ) -end - -function BMScreateBufferMemory_call( - arraygrowfac, - arraygrowinit, - clean, - filename, - line, -) - ccall( - (:BMScreateBufferMemory_call, libscip), - Ptr{BMS_BUFMEM}, - (Cdouble, Cint, Cuint, Ptr{Cchar}, Cint), - arraygrowfac, - arraygrowinit, - clean, - filename, - line, - ) +function BMScreateBufferMemory_call(arraygrowfac, arraygrowinit, clean, filename, line) + ccall((:BMScreateBufferMemory_call, libscip), Ptr{BMS_BUFMEM}, (Cdouble, Cint, Cuint, Ptr{Cchar}, Cint), arraygrowfac, arraygrowinit, clean, filename, line) end function BMSdestroyBufferMemory_call(buffer, filename, line) - ccall( - (:BMSdestroyBufferMemory_call, libscip), - Cvoid, - (Ptr{Ptr{BMS_BUFMEM}}, Ptr{Cchar}, Cint), - buffer, - filename, - line, - ) + ccall((:BMSdestroyBufferMemory_call, libscip), Cvoid, (Ptr{Ptr{BMS_BUFMEM}}, Ptr{Cchar}, Cint), buffer, filename, line) end function BMSalignMemsize(size) @@ -62279,41 +25649,19 @@ function BMSisAligned(size) end function BMSsetBufferMemoryArraygrowfac(buffer, arraygrowfac) - ccall( - (:BMSsetBufferMemoryArraygrowfac, libscip), - Cvoid, - (Ptr{BMS_BUFMEM}, Cdouble), - buffer, - arraygrowfac, - ) + ccall((:BMSsetBufferMemoryArraygrowfac, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Cdouble), buffer, arraygrowfac) end function BMSsetBufferMemoryArraygrowinit(buffer, arraygrowinit) - ccall( - (:BMSsetBufferMemoryArraygrowinit, libscip), - Cvoid, - (Ptr{BMS_BUFMEM}, Cint), - buffer, - arraygrowinit, - ) + ccall((:BMSsetBufferMemoryArraygrowinit, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Cint), buffer, arraygrowinit) end function BMSgetNUsedBufferMemory(buffer) - ccall( - (:BMSgetNUsedBufferMemory, libscip), - Csize_t, - (Ptr{BMS_BUFMEM},), - buffer, - ) + ccall((:BMSgetNUsedBufferMemory, libscip), Csize_t, (Ptr{BMS_BUFMEM},), buffer) end -function BMSgetBufferMemoryUsed(bufmem) - ccall( - (:BMSgetBufferMemoryUsed, libscip), - Clonglong, - (Ptr{BMS_BUFMEM},), - bufmem, - ) +function BMSgetBufferMemoryUsed(buffer) + ccall((:BMSgetBufferMemoryUsed, libscip), Clonglong, (Ptr{BMS_BUFMEM},), buffer) end function BMSprintBufferMemory(buffer) @@ -62329,23 +25677,11 @@ function SCIPlpiGetSolverDesc() end function SCIPlpiGetSolverPointer(lpi) - ccall( - (:SCIPlpiGetSolverPointer, libscip), - Ptr{Cvoid}, - (Ptr{SCIP_LPI},), - lpi, - ) + ccall((:SCIPlpiGetSolverPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP_LPI},), lpi) end function SCIPlpiSetIntegralityInformation(lpi, ncols, intInfo) - ccall( - (:SCIPlpiSetIntegralityInformation, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Ptr{Cint}), - lpi, - ncols, - intInfo, - ) + ccall((:SCIPlpiSetIntegralityInformation, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cint}), lpi, ncols, intInfo) end function SCIPlpiHasPrimalSolve() @@ -62368,172 +25704,39 @@ end const SCIP_OBJSEN = SCIP_ObjSen function SCIPlpiCreate(lpi, messagehdlr, name, objsen) - ccall( - (:SCIPlpiCreate, libscip), - SCIP_RETCODE, - (Ptr{Ptr{SCIP_LPI}}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, SCIP_OBJSEN), - lpi, - messagehdlr, - name, - objsen, - ) + ccall((:SCIPlpiCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LPI}}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, SCIP_OBJSEN), lpi, messagehdlr, name, objsen) end function SCIPlpiFree(lpi) ccall((:SCIPlpiFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LPI}},), lpi) end -function SCIPlpiLoadColLP( - lpi, - objsen, - ncols, - obj, - lb, - ub, - colnames, - nrows, - lhs, - rhs, - rownames, - nnonz, - beg, - ind, - val, -) - ccall( - (:SCIPlpiLoadColLP, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - SCIP_OBJSEN, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Ptr{Cchar}}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Ptr{Cchar}}, - Cint, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - ), - lpi, - objsen, - ncols, - obj, - lb, - ub, - colnames, - nrows, - lhs, - rhs, - rownames, - nnonz, - beg, - ind, - val, - ) +function SCIPlpiLoadColLP(lpi, objsen, ncols, obj, lb, ub, colnames, nrows, lhs, rhs, rownames, nnonz, beg, ind, val) + ccall((:SCIPlpiLoadColLP, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_OBJSEN, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, objsen, ncols, obj, lb, ub, colnames, nrows, lhs, rhs, rownames, nnonz, beg, ind, val) end function SCIPlpiAddCols(lpi, ncols, obj, lb, ub, colnames, nnonz, beg, ind, val) - ccall( - (:SCIPlpiAddCols, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Ptr{Cchar}}, - Cint, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - ), - lpi, - ncols, - obj, - lb, - ub, - colnames, - nnonz, - beg, - ind, - val, - ) + ccall((:SCIPlpiAddCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, ncols, obj, lb, ub, colnames, nnonz, beg, ind, val) end function SCIPlpiDelCols(lpi, firstcol, lastcol) - ccall( - (:SCIPlpiDelCols, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cint), - lpi, - firstcol, - lastcol, - ) + ccall((:SCIPlpiDelCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint), lpi, firstcol, lastcol) end function SCIPlpiDelColset(lpi, dstat) - ccall( - (:SCIPlpiDelColset, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}), - lpi, - dstat, - ) + ccall((:SCIPlpiDelColset, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, dstat) end function SCIPlpiAddRows(lpi, nrows, lhs, rhs, rownames, nnonz, beg, ind, val) - ccall( - (:SCIPlpiAddRows, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Ptr{Cchar}}, - Cint, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - ), - lpi, - nrows, - lhs, - rhs, - rownames, - nnonz, - beg, - ind, - val, - ) + ccall((:SCIPlpiAddRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, nrows, lhs, rhs, rownames, nnonz, beg, ind, val) end function SCIPlpiDelRows(lpi, firstrow, lastrow) - ccall( - (:SCIPlpiDelRows, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cint), - lpi, - firstrow, - lastrow, - ) + ccall((:SCIPlpiDelRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint), lpi, firstrow, lastrow) end function SCIPlpiDelRowset(lpi, dstat) - ccall( - (:SCIPlpiDelRowset, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}), - lpi, - dstat, - ) + ccall((:SCIPlpiDelRowset, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, dstat) end function SCIPlpiClear(lpi) @@ -62541,291 +25744,79 @@ function SCIPlpiClear(lpi) end function SCIPlpiChgBounds(lpi, ncols, ind, lb, ub) - ccall( - (:SCIPlpiChgBounds, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), - lpi, - ncols, - ind, - lb, - ub, - ) + ccall((:SCIPlpiChgBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), lpi, ncols, ind, lb, ub) end function SCIPlpiChgSides(lpi, nrows, ind, lhs, rhs) - ccall( - (:SCIPlpiChgSides, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), - lpi, - nrows, - ind, - lhs, - rhs, - ) + ccall((:SCIPlpiChgSides, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), lpi, nrows, ind, lhs, rhs) end function SCIPlpiChgCoef(lpi, row, col, newval) - ccall( - (:SCIPlpiChgCoef, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cint, Cdouble), - lpi, - row, - col, - newval, - ) + ccall((:SCIPlpiChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Cdouble), lpi, row, col, newval) end function SCIPlpiChgObjsen(lpi, objsen) - ccall( - (:SCIPlpiChgObjsen, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, SCIP_OBJSEN), - lpi, - objsen, - ) + ccall((:SCIPlpiChgObjsen, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_OBJSEN), lpi, objsen) end function SCIPlpiChgObj(lpi, ncols, ind, obj) - ccall( - (:SCIPlpiChgObj, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}), - lpi, - ncols, - ind, - obj, - ) + ccall((:SCIPlpiChgObj, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}), lpi, ncols, ind, obj) end function SCIPlpiScaleRow(lpi, row, scaleval) - ccall( - (:SCIPlpiScaleRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cdouble), - lpi, - row, - scaleval, - ) + ccall((:SCIPlpiScaleRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cdouble), lpi, row, scaleval) end function SCIPlpiScaleCol(lpi, col, scaleval) - ccall( - (:SCIPlpiScaleCol, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cdouble), - lpi, - col, - scaleval, - ) + ccall((:SCIPlpiScaleCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cdouble), lpi, col, scaleval) end function SCIPlpiGetNRows(lpi, nrows) - ccall( - (:SCIPlpiGetNRows, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}), - lpi, - nrows, - ) + ccall((:SCIPlpiGetNRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, nrows) end function SCIPlpiGetNCols(lpi, ncols) - ccall( - (:SCIPlpiGetNCols, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}), - lpi, - ncols, - ) + ccall((:SCIPlpiGetNCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, ncols) end function SCIPlpiGetObjsen(lpi, objsen) - ccall( - (:SCIPlpiGetObjsen, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{SCIP_OBJSEN}), - lpi, - objsen, - ) + ccall((:SCIPlpiGetObjsen, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{SCIP_OBJSEN}), lpi, objsen) end function SCIPlpiGetNNonz(lpi, nnonz) - ccall( - (:SCIPlpiGetNNonz, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}), - lpi, - nnonz, - ) + ccall((:SCIPlpiGetNNonz, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, nnonz) end function SCIPlpiGetCols(lpi, firstcol, lastcol, lb, ub, nnonz, beg, ind, val) - ccall( - (:SCIPlpiGetCols, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Cint, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - ), - lpi, - firstcol, - lastcol, - lb, - ub, - nnonz, - beg, - ind, - val, - ) + ccall((:SCIPlpiGetCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, firstcol, lastcol, lb, ub, nnonz, beg, ind, val) end function SCIPlpiGetRows(lpi, firstrow, lastrow, lhs, rhs, nnonz, beg, ind, val) - ccall( - (:SCIPlpiGetRows, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Cint, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cint}, - Ptr{Cdouble}, - ), - lpi, - firstrow, - lastrow, - lhs, - rhs, - nnonz, - beg, - ind, - val, - ) -end - -function SCIPlpiGetColNames( - lpi, - firstcol, - lastcol, - colnames, - namestorage, - namestoragesize, - storageleft, -) - ccall( - (:SCIPlpiGetColNames, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Cint, - Cint, - Ptr{Ptr{Cchar}}, - Ptr{Cchar}, - Cint, - Ptr{Cint}, - ), - lpi, - firstcol, - lastcol, - colnames, - namestorage, - namestoragesize, - storageleft, - ) -end - -function SCIPlpiGetRowNames( - lpi, - firstrow, - lastrow, - rownames, - namestorage, - namestoragesize, - storageleft, -) - ccall( - (:SCIPlpiGetRowNames, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Cint, - Cint, - Ptr{Ptr{Cchar}}, - Ptr{Cchar}, - Cint, - Ptr{Cint}, - ), - lpi, - firstrow, - lastrow, - rownames, - namestorage, - namestoragesize, - storageleft, - ) + ccall((:SCIPlpiGetRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, firstrow, lastrow, lhs, rhs, nnonz, beg, ind, val) +end + +function SCIPlpiGetColNames(lpi, firstcol, lastcol, colnames, namestorage, namestoragesize, storageleft) + ccall((:SCIPlpiGetColNames, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}, Cint, Ptr{Cint}), lpi, firstcol, lastcol, colnames, namestorage, namestoragesize, storageleft) +end + +function SCIPlpiGetRowNames(lpi, firstrow, lastrow, rownames, namestorage, namestoragesize, storageleft) + ccall((:SCIPlpiGetRowNames, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}, Cint, Ptr{Cint}), lpi, firstrow, lastrow, rownames, namestorage, namestoragesize, storageleft) end function SCIPlpiGetObj(lpi, firstcol, lastcol, vals) - ccall( - (:SCIPlpiGetObj, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}), - lpi, - firstcol, - lastcol, - vals, - ) + ccall((:SCIPlpiGetObj, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}), lpi, firstcol, lastcol, vals) end function SCIPlpiGetBounds(lpi, firstcol, lastcol, lbs, ubs) - ccall( - (:SCIPlpiGetBounds, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), - lpi, - firstcol, - lastcol, - lbs, - ubs, - ) + ccall((:SCIPlpiGetBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), lpi, firstcol, lastcol, lbs, ubs) end function SCIPlpiGetSides(lpi, firstrow, lastrow, lhss, rhss) - ccall( - (:SCIPlpiGetSides, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), - lpi, - firstrow, - lastrow, - lhss, - rhss, - ) + ccall((:SCIPlpiGetSides, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), lpi, firstrow, lastrow, lhss, rhss) end function SCIPlpiGetCoef(lpi, row, col, val) - ccall( - (:SCIPlpiGetCoef, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}), - lpi, - row, - col, - val, - ) + ccall((:SCIPlpiGetCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}), lpi, row, col, val) end function SCIPlpiSolvePrimal(lpi) @@ -62837,185 +25828,31 @@ function SCIPlpiSolveDual(lpi) end function SCIPlpiSolveBarrier(lpi, crossover) - ccall( - (:SCIPlpiSolveBarrier, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cuint), - lpi, - crossover, - ) + ccall((:SCIPlpiSolveBarrier, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cuint), lpi, crossover) end function SCIPlpiStartStrongbranch(lpi) - ccall( - (:SCIPlpiStartStrongbranch, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI},), - lpi, - ) + ccall((:SCIPlpiStartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI},), lpi) end function SCIPlpiEndStrongbranch(lpi) - ccall( - (:SCIPlpiEndStrongbranch, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI},), - lpi, - ) -end - -function SCIPlpiStrongbranchFrac( - lpi, - col, - psol, - itlim, - down, - up, - downvalid, - upvalid, - iter, -) - ccall( - (:SCIPlpiStrongbranchFrac, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Cint, - Cdouble, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cint}, - ), - lpi, - col, - psol, - itlim, - down, - up, - downvalid, - upvalid, - iter, - ) -end - -function SCIPlpiStrongbranchesFrac( - lpi, - cols, - ncols, - psols, - itlim, - down, - up, - downvalid, - upvalid, - iter, -) - ccall( - (:SCIPlpiStrongbranchesFrac, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Ptr{Cint}, - Cint, - Ptr{Cdouble}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cint}, - ), - lpi, - cols, - ncols, - psols, - itlim, - down, - up, - downvalid, - upvalid, - iter, - ) -end - -function SCIPlpiStrongbranchInt( - lpi, - col, - psol, - itlim, - down, - up, - downvalid, - upvalid, - iter, -) - ccall( - (:SCIPlpiStrongbranchInt, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Cint, - Cdouble, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cint}, - ), - lpi, - col, - psol, - itlim, - down, - up, - downvalid, - upvalid, - iter, - ) -end - -function SCIPlpiStrongbranchesInt( - lpi, - cols, - ncols, - psols, - itlim, - down, - up, - downvalid, - upvalid, - iter, -) - ccall( - (:SCIPlpiStrongbranchesInt, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Ptr{Cint}, - Cint, - Ptr{Cdouble}, - Cint, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cuint}, - Ptr{Cuint}, - Ptr{Cint}, - ), - lpi, - cols, - ncols, - psols, - itlim, - down, - up, - downvalid, - upvalid, - iter, - ) + ccall((:SCIPlpiEndStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI},), lpi) +end + +function SCIPlpiStrongbranchFrac(lpi, col, psol, itlim, down, up, downvalid, upvalid, iter) + ccall((:SCIPlpiStrongbranchFrac, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cdouble, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}), lpi, col, psol, itlim, down, up, downvalid, upvalid, iter) +end + +function SCIPlpiStrongbranchesFrac(lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter) + ccall((:SCIPlpiStrongbranchesFrac, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}, Cint, Ptr{Cdouble}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}), lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter) +end + +function SCIPlpiStrongbranchInt(lpi, col, psol, itlim, down, up, downvalid, upvalid, iter) + ccall((:SCIPlpiStrongbranchInt, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cdouble, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}), lpi, col, psol, itlim, down, up, downvalid, upvalid, iter) +end + +function SCIPlpiStrongbranchesInt(lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter) + ccall((:SCIPlpiStrongbranchesInt, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}, Cint, Ptr{Cdouble}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}), lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter) end function SCIPlpiWasSolved(lpi) @@ -63023,14 +25860,7 @@ function SCIPlpiWasSolved(lpi) end function SCIPlpiGetSolFeasibility(lpi, primalfeasible, dualfeasible) - ccall( - (:SCIPlpiGetSolFeasibility, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cuint}, Ptr{Cuint}), - lpi, - primalfeasible, - dualfeasible, - ) + ccall((:SCIPlpiGetSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cuint}, Ptr{Cuint}), lpi, primalfeasible, dualfeasible) end function SCIPlpiExistsPrimalRay(lpi) @@ -63098,74 +25928,27 @@ function SCIPlpiGetInternalStatus(lpi) end function SCIPlpiIgnoreInstability(lpi, success) - ccall( - (:SCIPlpiIgnoreInstability, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cuint}), - lpi, - success, - ) + ccall((:SCIPlpiIgnoreInstability, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cuint}), lpi, success) end function SCIPlpiGetObjval(lpi, objval) - ccall( - (:SCIPlpiGetObjval, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cdouble}), - lpi, - objval, - ) + ccall((:SCIPlpiGetObjval, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cdouble}), lpi, objval) end function SCIPlpiGetSol(lpi, objval, primsol, dualsol, activity, redcost) - ccall( - (:SCIPlpiGetSol, libscip), - SCIP_RETCODE, - ( - Ptr{SCIP_LPI}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - Ptr{Cdouble}, - ), - lpi, - objval, - primsol, - dualsol, - activity, - redcost, - ) + ccall((:SCIPlpiGetSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), lpi, objval, primsol, dualsol, activity, redcost) end function SCIPlpiGetPrimalRay(lpi, ray) - ccall( - (:SCIPlpiGetPrimalRay, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cdouble}), - lpi, - ray, - ) + ccall((:SCIPlpiGetPrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cdouble}), lpi, ray) end function SCIPlpiGetDualfarkas(lpi, dualfarkas) - ccall( - (:SCIPlpiGetDualfarkas, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cdouble}), - lpi, - dualfarkas, - ) + ccall((:SCIPlpiGetDualfarkas, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cdouble}), lpi, dualfarkas) end function SCIPlpiGetIterations(lpi, iterations) - ccall( - (:SCIPlpiGetIterations, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}), - lpi, - iterations, - ) + ccall((:SCIPlpiGetIterations, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, iterations) end @enum SCIP_LPSolQuality::UInt32 begin @@ -63176,121 +25959,43 @@ end const SCIP_LPSOLQUALITY = SCIP_LPSolQuality function SCIPlpiGetRealSolQuality(lpi, qualityindicator, quality) - ccall( - (:SCIPlpiGetRealSolQuality, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, SCIP_LPSOLQUALITY, Ptr{Cdouble}), - lpi, - qualityindicator, - quality, - ) + ccall((:SCIPlpiGetRealSolQuality, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPSOLQUALITY, Ptr{Cdouble}), lpi, qualityindicator, quality) end function SCIPlpiGetBase(lpi, cstat, rstat) - ccall( - (:SCIPlpiGetBase, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}, Ptr{Cint}), - lpi, - cstat, - rstat, - ) + ccall((:SCIPlpiGetBase, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}, Ptr{Cint}), lpi, cstat, rstat) end function SCIPlpiSetBase(lpi, cstat, rstat) - ccall( - (:SCIPlpiSetBase, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}, Ptr{Cint}), - lpi, - cstat, - rstat, - ) + ccall((:SCIPlpiSetBase, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}, Ptr{Cint}), lpi, cstat, rstat) end function SCIPlpiGetBasisInd(lpi, bind) - ccall( - (:SCIPlpiGetBasisInd, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cint}), - lpi, - bind, - ) + ccall((:SCIPlpiGetBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, bind) end function SCIPlpiGetBInvRow(lpi, r, coef, inds, ninds) - ccall( - (:SCIPlpiGetBInvRow, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), - lpi, - r, - coef, - inds, - ninds, - ) + ccall((:SCIPlpiGetBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lpi, r, coef, inds, ninds) end function SCIPlpiGetBInvCol(lpi, c, coef, inds, ninds) - ccall( - (:SCIPlpiGetBInvCol, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), - lpi, - c, - coef, - inds, - ninds, - ) + ccall((:SCIPlpiGetBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lpi, c, coef, inds, ninds) end function SCIPlpiGetBInvARow(lpi, r, binvrow, coef, inds, ninds) - ccall( - (:SCIPlpiGetBInvARow, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), - lpi, - r, - binvrow, - coef, - inds, - ninds, - ) + ccall((:SCIPlpiGetBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lpi, r, binvrow, coef, inds, ninds) end function SCIPlpiGetBInvACol(lpi, c, coef, inds, ninds) - ccall( - (:SCIPlpiGetBInvACol, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), - lpi, - c, - coef, - inds, - ninds, - ) + ccall((:SCIPlpiGetBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lpi, c, coef, inds, ninds) end function SCIPlpiGetState(lpi, blkmem, lpistate) - ccall( - (:SCIPlpiGetState, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), - lpi, - blkmem, - lpistate, - ) + ccall((:SCIPlpiGetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lpi, blkmem, lpistate) end function SCIPlpiSetState(lpi, blkmem, lpistate) - ccall( - (:SCIPlpiSetState, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPISTATE}), - lpi, - blkmem, - lpistate, - ) + ccall((:SCIPlpiSetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPISTATE}), lpi, blkmem, lpistate) end function SCIPlpiClearState(lpi) @@ -63298,77 +26003,31 @@ function SCIPlpiClearState(lpi) end function SCIPlpiFreeState(lpi, blkmem, lpistate) - ccall( - (:SCIPlpiFreeState, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), - lpi, - blkmem, - lpistate, - ) + ccall((:SCIPlpiFreeState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lpi, blkmem, lpistate) end function SCIPlpiHasStateBasis(lpi, lpistate) - ccall( - (:SCIPlpiHasStateBasis, libscip), - Cuint, - (Ptr{SCIP_LPI}, Ptr{SCIP_LPISTATE}), - lpi, - lpistate, - ) + ccall((:SCIPlpiHasStateBasis, libscip), Cuint, (Ptr{SCIP_LPI}, Ptr{SCIP_LPISTATE}), lpi, lpistate) end function SCIPlpiReadState(lpi, fname) - ccall( - (:SCIPlpiReadState, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cchar}), - lpi, - fname, - ) + ccall((:SCIPlpiReadState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cchar}), lpi, fname) end function SCIPlpiWriteState(lpi, fname) - ccall( - (:SCIPlpiWriteState, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cchar}), - lpi, - fname, - ) + ccall((:SCIPlpiWriteState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cchar}), lpi, fname) end function SCIPlpiGetNorms(lpi, blkmem, lpinorms) - ccall( - (:SCIPlpiGetNorms, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), - lpi, - blkmem, - lpinorms, - ) + ccall((:SCIPlpiGetNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), lpi, blkmem, lpinorms) end function SCIPlpiSetNorms(lpi, blkmem, lpinorms) - ccall( - (:SCIPlpiSetNorms, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPINORMS}), - lpi, - blkmem, - lpinorms, - ) + ccall((:SCIPlpiSetNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPINORMS}), lpi, blkmem, lpinorms) end function SCIPlpiFreeNorms(lpi, blkmem, lpinorms) - ccall( - (:SCIPlpiFreeNorms, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), - lpi, - blkmem, - lpinorms, - ) + ccall((:SCIPlpiFreeNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), lpi, blkmem, lpinorms) end @enum SCIP_LPParam::UInt32 begin @@ -63397,57 +26056,23 @@ end const SCIP_LPPARAM = SCIP_LPParam function SCIPlpiGetIntpar(lpi, type, ival) - ccall( - (:SCIPlpiGetIntpar, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, SCIP_LPPARAM, Ptr{Cint}), - lpi, - type, - ival, - ) + ccall((:SCIPlpiGetIntpar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPPARAM, Ptr{Cint}), lpi, type, ival) end function SCIPlpiSetIntpar(lpi, type, ival) - ccall( - (:SCIPlpiSetIntpar, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, SCIP_LPPARAM, Cint), - lpi, - type, - ival, - ) + ccall((:SCIPlpiSetIntpar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPPARAM, Cint), lpi, type, ival) end function SCIPlpiGetRealpar(lpi, type, dval) - ccall( - (:SCIPlpiGetRealpar, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, SCIP_LPPARAM, Ptr{Cdouble}), - lpi, - type, - dval, - ) + ccall((:SCIPlpiGetRealpar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPPARAM, Ptr{Cdouble}), lpi, type, dval) end function SCIPlpiSetRealpar(lpi, type, dval) - ccall( - (:SCIPlpiSetRealpar, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, SCIP_LPPARAM, Cdouble), - lpi, - type, - dval, - ) + ccall((:SCIPlpiSetRealpar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPPARAM, Cdouble), lpi, type, dval) end function SCIPlpiInterrupt(lpi, interrupt) - ccall( - (:SCIPlpiInterrupt, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Cuint), - lpi, - interrupt, - ) + ccall((:SCIPlpiInterrupt, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cuint), lpi, interrupt) end function SCIPlpiInfinity(lpi) @@ -63455,59 +26080,17 @@ function SCIPlpiInfinity(lpi) end function SCIPlpiIsInfinity(lpi, val) - ccall( - (:SCIPlpiIsInfinity, libscip), - Cuint, - (Ptr{SCIP_LPI}, Cdouble), - lpi, - val, - ) + ccall((:SCIPlpiIsInfinity, libscip), Cuint, (Ptr{SCIP_LPI}, Cdouble), lpi, val) end function SCIPlpiReadLP(lpi, fname) - ccall( - (:SCIPlpiReadLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cchar}), - lpi, - fname, - ) + ccall((:SCIPlpiReadLP, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cchar}), lpi, fname) end function SCIPlpiWriteLP(lpi, fname) - ccall( - (:SCIPlpiWriteLP, libscip), - SCIP_RETCODE, - (Ptr{SCIP_LPI}, Ptr{Cchar}), - lpi, - fname, - ) -end - -@enum SCIP_Pricing::UInt32 begin - 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 + ccall((:SCIPlpiWriteLP, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cchar}), lpi, fname) end -const SCIP_PRICING = SCIP_Pricing - -const CMAKE_BUILD_TYPE = "Release" - -const SCIP_VERSION_MAJOR = 7 - -const SCIP_VERSION_MINOR = 0 - -const SCIP_VERSION_PATCH = 3 - -const SCIP_VERSION_SUB = 5 - -const SCIP_VERSION_API = 77 - # Skipping MacroDefinition: SCIP_EXPORT __attribute__ ( ( visibility ( "default" ) ) ) # Skipping MacroDefinition: SCIP_NO_EXPORT __attribute__ ( ( visibility ( "hidden" ) ) ) @@ -63562,116 +26145,85 @@ const SCIP_EVENTTYPE_IMPLADDED = UINT64_C(0x0000000000008000) const SCIP_EVENTTYPE_TYPECHANGED = UINT64_C(0x0000000000010000) -const SCIP_EVENTTYPE_PRESOLVEROUND = UINT64_C(0x0000000000020000) +const SCIP_EVENTTYPE_IMPLTYPECHANGED = UINT64_C(0x0000000000020000) -const SCIP_EVENTTYPE_NODEFOCUSED = UINT64_C(0x0000000000040000) +const SCIP_EVENTTYPE_PRESOLVEROUND = UINT64_C(0x0000000000040000) -const SCIP_EVENTTYPE_NODEFEASIBLE = UINT64_C(0x0000000000080000) +const SCIP_EVENTTYPE_NODEFOCUSED = UINT64_C(0x0000000000080000) -const SCIP_EVENTTYPE_NODEINFEASIBLE = UINT64_C(0x0000000000100000) +const SCIP_EVENTTYPE_NODEFEASIBLE = UINT64_C(0x0000000000100000) -const SCIP_EVENTTYPE_NODEBRANCHED = UINT64_C(0x0000000000200000) +const SCIP_EVENTTYPE_NODEINFEASIBLE = UINT64_C(0x0000000000200000) -const SCIP_EVENTTYPE_NODEDELETE = UINT64_C(0x0000000000400000) +const SCIP_EVENTTYPE_NODEBRANCHED = UINT64_C(0x0000000000400000) -const SCIP_EVENTTYPE_FIRSTLPSOLVED = UINT64_C(0x0000000000800000) +const SCIP_EVENTTYPE_NODEDELETE = UINT64_C(0x0000000000800000) -const SCIP_EVENTTYPE_LPSOLVED = UINT64_C(0x0000000001000000) +const SCIP_EVENTTYPE_DUALBOUNDIMPROVED = UINT64_C(0x0000000001000000) -const SCIP_EVENTTYPE_POORSOLFOUND = UINT64_C(0x0000000002000000) +const SCIP_EVENTTYPE_FIRSTLPSOLVED = UINT64_C(0x0000000002000000) -const SCIP_EVENTTYPE_BESTSOLFOUND = UINT64_C(0x0000000004000000) +const SCIP_EVENTTYPE_LPSOLVED = UINT64_C(0x0000000004000000) -const SCIP_EVENTTYPE_ROWADDEDSEPA = UINT64_C(0x0000000008000000) +const SCIP_EVENTTYPE_POORSOLFOUND = UINT64_C(0x0000000008000000) -const SCIP_EVENTTYPE_ROWDELETEDSEPA = UINT64_C(0x0000000010000000) +const SCIP_EVENTTYPE_BESTSOLFOUND = UINT64_C(0x0000000010000000) -const SCIP_EVENTTYPE_ROWADDEDLP = UINT64_C(0x0000000020000000) +const SCIP_EVENTTYPE_ROWADDEDSEPA = UINT64_C(0x0000000020000000) -const SCIP_EVENTTYPE_ROWDELETEDLP = UINT64_C(0x0000000040000000) +const SCIP_EVENTTYPE_ROWDELETEDSEPA = UINT64_C(0x0000000040000000) -const SCIP_EVENTTYPE_ROWCOEFCHANGED = UINT64_C(0x0000000080000000) +const SCIP_EVENTTYPE_ROWADDEDLP = UINT64_C(0x0000000080000000) -const SCIP_EVENTTYPE_ROWCONSTCHANGED = UINT64_C(0x0000000100000000) +const SCIP_EVENTTYPE_ROWDELETEDLP = UINT64_C(0x0000000100000000) -const SCIP_EVENTTYPE_ROWSIDECHANGED = UINT64_C(0x0000000200000000) +const SCIP_EVENTTYPE_ROWCOEFCHANGED = UINT64_C(0x0000000200000000) -const SCIP_EVENTTYPE_SYNC = UINT64_C(0x0000000400000000) +const SCIP_EVENTTYPE_ROWCONSTCHANGED = UINT64_C(0x0000000400000000) -const SCIP_EVENTTYPE_GBDCHANGED = - SCIP_EVENTTYPE_GLBCHANGED | SCIP_EVENTTYPE_GUBCHANGED +const SCIP_EVENTTYPE_ROWSIDECHANGED = UINT64_C(0x0000000800000000) -const SCIP_EVENTTYPE_LBCHANGED = - SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED +const SCIP_EVENTTYPE_SYNC = UINT64_C(0x0000001000000000) -const SCIP_EVENTTYPE_UBCHANGED = - SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_UBRELAXED +const SCIP_EVENTTYPE_GBDCHANGED = SCIP_EVENTTYPE_GLBCHANGED | SCIP_EVENTTYPE_GUBCHANGED -const SCIP_EVENTTYPE_BOUNDTIGHTENED = - SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_UBTIGHTENED +const SCIP_EVENTTYPE_LBCHANGED = SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED -const SCIP_EVENTTYPE_BOUNDRELAXED = - SCIP_EVENTTYPE_LBRELAXED | SCIP_EVENTTYPE_UBRELAXED +const SCIP_EVENTTYPE_UBCHANGED = SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_UBRELAXED -const SCIP_EVENTTYPE_BOUNDCHANGED = - SCIP_EVENTTYPE_LBCHANGED | SCIP_EVENTTYPE_UBCHANGED +const SCIP_EVENTTYPE_BOUNDTIGHTENED = SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_UBTIGHTENED -const SCIP_EVENTTYPE_GHOLECHANGED = - SCIP_EVENTTYPE_GHOLEADDED | SCIP_EVENTTYPE_GHOLEREMOVED +const SCIP_EVENTTYPE_BOUNDRELAXED = SCIP_EVENTTYPE_LBRELAXED | SCIP_EVENTTYPE_UBRELAXED -const SCIP_EVENTTYPE_LHOLECHANGED = - SCIP_EVENTTYPE_LHOLEADDED | SCIP_EVENTTYPE_LHOLEREMOVED +const SCIP_EVENTTYPE_BOUNDCHANGED = SCIP_EVENTTYPE_LBCHANGED | SCIP_EVENTTYPE_UBCHANGED -const SCIP_EVENTTYPE_HOLECHANGED = - SCIP_EVENTTYPE_GHOLECHANGED | SCIP_EVENTTYPE_LHOLECHANGED +const SCIP_EVENTTYPE_GHOLECHANGED = SCIP_EVENTTYPE_GHOLEADDED | SCIP_EVENTTYPE_GHOLEREMOVED -const SCIP_EVENTTYPE_DOMCHANGED = - SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_HOLECHANGED +const SCIP_EVENTTYPE_LHOLECHANGED = SCIP_EVENTTYPE_LHOLEADDED | SCIP_EVENTTYPE_LHOLEREMOVED -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 - ) | SCIP_EVENTTYPE_TYPECHANGED +const SCIP_EVENTTYPE_HOLECHANGED = SCIP_EVENTTYPE_GHOLECHANGED | SCIP_EVENTTYPE_LHOLECHANGED -const SCIP_EVENTTYPE_VAREVENT = - (SCIP_EVENTTYPE_VARADDED | SCIP_EVENTTYPE_VARCHANGED) | - SCIP_EVENTTYPE_TYPECHANGED +const SCIP_EVENTTYPE_DOMCHANGED = SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_HOLECHANGED -const SCIP_EVENTTYPE_NODESOLVED = - (SCIP_EVENTTYPE_NODEFEASIBLE | SCIP_EVENTTYPE_NODEINFEASIBLE) | - SCIP_EVENTTYPE_NODEBRANCHED +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) | SCIP_EVENTTYPE_TYPECHANGED) | SCIP_EVENTTYPE_IMPLTYPECHANGED -const SCIP_EVENTTYPE_NODEEVENT = - SCIP_EVENTTYPE_NODEFOCUSED | SCIP_EVENTTYPE_NODESOLVED +const SCIP_EVENTTYPE_VAREVENT = SCIP_EVENTTYPE_VARADDED | SCIP_EVENTTYPE_VARCHANGED -const SCIP_EVENTTYPE_LPEVENT = - SCIP_EVENTTYPE_FIRSTLPSOLVED | SCIP_EVENTTYPE_LPSOLVED +const SCIP_EVENTTYPE_NODESOLVED = (SCIP_EVENTTYPE_NODEFEASIBLE | SCIP_EVENTTYPE_NODEINFEASIBLE) | SCIP_EVENTTYPE_NODEBRANCHED -const SCIP_EVENTTYPE_SOLFOUND = - SCIP_EVENTTYPE_POORSOLFOUND | SCIP_EVENTTYPE_BESTSOLFOUND +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_GAPUPDATED = SCIP_EVENTTYPE_BESTSOLFOUND | SCIP_EVENTTYPE_DUALBOUNDIMPROVED -const SCIP_EVENTTYPE_ROWEVENT = - ( - ( - (SCIP_EVENTTYPE_ROWADDEDSEPA | SCIP_EVENTTYPE_ROWDELETEDSEPA) | - SCIP_EVENTTYPE_ROWADDEDLP - ) | SCIP_EVENTTYPE_ROWDELETEDLP - ) | SCIP_EVENTTYPE_ROWCHANGED +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 @@ -63687,11 +26239,7 @@ const SCIP_EXPRITER_VISITEDCHILD = Cuint(4) const SCIP_EXPRITER_LEAVEEXPR = Cuint(8) -const SCIP_EXPRITER_ALLSTAGES = - ( - (SCIP_EXPRITER_ENTEREXPR | SCIP_EXPRITER_VISITINGCHILD) | - SCIP_EXPRITER_VISITEDCHILD - ) | SCIP_EXPRITER_LEAVEEXPR +const SCIP_EXPRITER_ALLSTAGES = ((SCIP_EXPRITER_ENTEREXPR | SCIP_EXPRITER_VISITINGCHILD) | SCIP_EXPRITER_VISITEDCHILD) | SCIP_EXPRITER_LEAVEEXPR const SCIP_EXPRPRINT_EXPRSTRING = Cuint(0x01) @@ -63709,15 +26257,7 @@ const SCIP_EXPRPRINT_ACTIVITYTAG = Cuint(0x60) const SCIP_EXPRPRINT_OWNER = Cuint(0x80) -const SCIP_EXPRPRINT_ALL = - ( - ( - ( - (SCIP_EXPRPRINT_EXPRSTRING | SCIP_EXPRPRINT_EXPRHDLR) | - SCIP_EXPRPRINT_NUSES - ) | SCIP_EXPRPRINT_EVALTAG - ) | SCIP_EXPRPRINT_ACTIVITYTAG - ) | SCIP_EXPRPRINT_OWNER +const SCIP_EXPRPRINT_ALL = ((((SCIP_EXPRPRINT_EXPRSTRING | SCIP_EXPRPRINT_EXPRHDLR) | SCIP_EXPRPRINT_NUSES) | SCIP_EXPRPRINT_EVALTAG) | SCIP_EXPRPRINT_ACTIVITYTAG) | SCIP_EXPRPRINT_OWNER const SCIP_EXPRINTCAPABILITY_NONE = 0x00000000 @@ -63727,9 +26267,7 @@ const SCIP_EXPRINTCAPABILITY_GRADIENT = 0x00000010 const SCIP_EXPRINTCAPABILITY_HESSIAN = 0x00000100 -const SCIP_EXPRINTCAPABILITY_ALL = - (SCIP_EXPRINTCAPABILITY_FUNCVALUE | SCIP_EXPRINTCAPABILITY_GRADIENT) | - SCIP_EXPRINTCAPABILITY_HESSIAN +const SCIP_EXPRINTCAPABILITY_ALL = (SCIP_EXPRINTCAPABILITY_FUNCVALUE | SCIP_EXPRINTCAPABILITY_GRADIENT) | SCIP_EXPRINTCAPABILITY_HESSIAN const SCIP_DIVETYPE_NONE = Cuint(0x0000) @@ -63757,13 +26295,11 @@ const SCIP_NLHDLR_METHOD_SEPABELOW = Cuint(0x01) const SCIP_NLHDLR_METHOD_SEPAABOVE = Cuint(0x02) -const SCIP_NLHDLR_METHOD_SEPABOTH = - SCIP_NLHDLR_METHOD_SEPABELOW | SCIP_NLHDLR_METHOD_SEPAABOVE +const SCIP_NLHDLR_METHOD_SEPABOTH = SCIP_NLHDLR_METHOD_SEPABELOW | SCIP_NLHDLR_METHOD_SEPAABOVE const SCIP_NLHDLR_METHOD_ACTIVITY = Cuint(0x04) -const SCIP_NLHDLR_METHOD_ALL = - SCIP_NLHDLR_METHOD_SEPABOTH | SCIP_NLHDLR_METHOD_ACTIVITY +const SCIP_NLHDLR_METHOD_ALL = SCIP_NLHDLR_METHOD_SEPABOTH | SCIP_NLHDLR_METHOD_ACTIVITY const SCIP_NLPPARAM_DEFAULT_VERBLEVEL = 0 @@ -63783,15 +26319,11 @@ const SCIP_PRESOLTIMING_EXHAUSTIVE = Cuint(0x0010) const SCIP_PRESOLTIMING_FINAL = Cuint(0x0020) -const SCIP_PRESOLTIMING_ALWAYS = - (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM) | - SCIP_PRESOLTIMING_EXHAUSTIVE +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_PRESOLTIMING_MAX = - ( - (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM) | - SCIP_PRESOLTIMING_EXHAUSTIVE - ) | SCIP_PRESOLTIMING_FINAL +const SCIP_PROPTIMING_NONE = Cuint(0x0000) const SCIP_PROPTIMING_BEFORELP = Cuint(0x0001) @@ -63801,11 +26333,9 @@ const SCIP_PROPTIMING_AFTERLPLOOP = Cuint(0x0004) const SCIP_PROPTIMING_AFTERLPNODE = Cuint(0x0008) -const SCIP_PROPTIMING_ALWAYS = - ( - (SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP) | - SCIP_PROPTIMING_AFTERLPLOOP - ) | SCIP_PROPTIMING_AFTERLPNODE +const SCIP_PROPTIMING_ALWAYS = ((SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP) | SCIP_PROPTIMING_AFTERLPLOOP) | SCIP_PROPTIMING_AFTERLPNODE + +const SCIP_HEURTIMING_NONE = Cuint(0x0000) const SCIP_HEURTIMING_BEFORENODE = Cuint(0x0001) @@ -63829,11 +26359,19 @@ const SCIP_HEURTIMING_DURINGPRESOLLOOP = Cuint(0x0200) const SCIP_HEURTIMING_AFTERPROPLOOP = Cuint(0x0400) -const SCIP_HEURTIMING_AFTERNODE = - SCIP_HEURTIMING_AFTERLPNODE | SCIP_HEURTIMING_AFTERPSEUDONODE +const SCIP_HEURTIMING_AFTERNODE = SCIP_HEURTIMING_AFTERLPNODE | SCIP_HEURTIMING_AFTERPSEUDONODE + +const SCIP_HEURTIMING_AFTERPLUNGE = SCIP_HEURTIMING_AFTERLPPLUNGE | SCIP_HEURTIMING_AFTERPSEUDOPLUNGE + +const SCIP_DEPRECATED_VARTYPE_IMPLINT = SCIP_VARTYPE(2) + +const SCIP_VARTYPE_BINARY_CHAR = Cchar('B') + +const SCIP_VARTYPE_INTEGER_CHAR = Cchar('I') + +const SCIP_VARTYPE_CONTINUOUS_CHAR = Cchar('C') -const SCIP_HEURTIMING_AFTERPLUNGE = - SCIP_HEURTIMING_AFTERLPPLUNGE | SCIP_HEURTIMING_AFTERPSEUDOPLUNGE +const SCIP_DEPRECATED_VARTYPE_IMPLINT_CHAR = Cchar('M') const NLOCKTYPES = 2 @@ -63843,21 +26381,23 @@ const TRUE = 1 const SCIP_Shortbool = uint8_t -const SCIP_VERSION = 800 +const SCIP_VERSION_MAJOR = 10 -const SCIP_SUBVERSION = 1 +const SCIP_VERSION_MINOR = 0 -const SCIP_APIVERSION = 101 +const SCIP_VERSION_PATCH = 0 -const SCIP_COPYRIGHT = "Copyright (C) 2002-2021 Konrad-Zuse-Zentrum fuer Informationstechnik Berlin (ZIB)" +const SCIP_VERSION = 100SCIP_VERSION_MAJOR + 10SCIP_VERSION_MINOR + SCIP_VERSION_PATCH -const SCIP_VARTYPE_BINARY_CHAR = Cchar('B') +const SCIP_VERSION_SUB = 0 -const SCIP_VARTYPE_INTEGER_CHAR = Cchar('I') +const SCIP_SUBVERSION = SCIP_VERSION_SUB -const SCIP_VARTYPE_IMPLINT_CHAR = Cchar('M') +const SCIP_VERSION_API = 156 -const SCIP_VARTYPE_CONTINUOUS_CHAR = Cchar('C') +const SCIP_APIVERSION = SCIP_VERSION_API + +const SCIP_COPYRIGHT = "Copyright (c) 2002-2025 Zuse Institute Berlin (ZIB)" const SCIP_LONGINT_MAX = LLONG_MAX @@ -63865,6 +26405,8 @@ const SCIP_LONGINT_MIN = LLONG_MIN const SCIP_LONGINT_FORMAT = "lld" +const SCIP_REAL_UNITROUNDOFF = 1.0 ÷ 9007199254740992 + const SCIP_REAL_FORMAT = "lf" const SCIP_DEFAULT_INFINITY = 1.0e20 @@ -63889,7 +26431,7 @@ const SCIP_DEFAULT_PSEUDOCOSTEPS = 0.1 const SCIP_DEFAULT_PSEUDOCOSTDELTA = 0.0001 -const SCIP_DEFAULT_RECOMPFAC = 1.0e7 +const SCIP_DEFAULT_RECOMPFAC = 1.0e6 const SCIP_DEFAULT_HUGEVAL = 1.0e15 @@ -63907,6 +26449,8 @@ const COPYSIGN = copysign const SCIP_MAXSTRLEN = 1024 +const SCIP_SPACECONTROL = " tnvfr" + const SCIP_MAXMEMSIZE = SIZE_MAX ÷ 2 const SCIP_HASHSIZE_PARAMS = 2048 @@ -63931,7 +26475,7 @@ const SCIP_DEFAULT_MEM_ARRAYGROWINIT = 4 const SCIP_MEM_NOLIMIT = SCIP_Longint(SCIP_LONGINT_MAX >> 20) -const SCIP_MAXTREEDEPTH = 65534 +const SCIP_MAXTREEDEPTH = 1073741822 const SCIP_PROBINGSCORE_PENALTYRATIO = 2 @@ -63945,17 +26489,23 @@ const SYM_SPEC_BINARY = UINT32_C(0x00000002) const SYM_SPEC_REAL = UINT32_C(0x00000004) -const SYM_COMPUTETIMING_BEFOREPRESOL = 0 +const SYM_TIMING_BEFOREPRESOL = 0 -const SYM_COMPUTETIMING_DURINGPRESOL = 1 +const SYM_TIMING_DURINGPRESOL = 1 -const SYM_COMPUTETIMING_AFTERPRESOL = 2 +const SYM_TIMING_AFTERPRESOL = 2 + +const SYM_COMPUTETIMING_BEFOREPRESOL = SYM_TIMING_BEFOREPRESOL + +const SYM_COMPUTETIMING_DURINGPRESOL = SYM_TIMING_DURINGPRESOL + +const SYM_COMPUTETIMING_AFTERPRESOL = SYM_TIMING_AFTERPRESOL const SYM_HANDLETYPE_NONE = UINT32_C(0x00000000) const SYM_HANDLETYPE_SYMBREAK = UINT32_C(0x00000001) -const SYM_HANDLETYPE_ORBITALFIXING = UINT32_C(0x00000002) +const SYM_HANDLETYPE_ORBITALREDUCTION = UINT32_C(0x00000002) const SYM_HANDLETYPE_SST = UINT32_C(0x00000004) @@ -63963,6 +26513,8 @@ const SYM_HANDLETYPE_SYMCONS = SYM_HANDLETYPE_SYMBREAK | SYM_HANDLETYPE_SST const ARTIFICIALVARNAMEPREFIX = "andresultant_" +const SCIP_BUILD_TYPE = "Release" + # Skipping MacroDefinition: SCIPdebugMessage while ( FALSE ) /*lint -e{530}*/ printf # Skipping MacroDefinition: SCIPdebugPrintf while ( FALSE ) /*lint -e{530}*/ printf @@ -63974,7 +26526,7 @@ const ARTIFICIALVARNAMEPREFIX = "andresultant_" const SCIPisFinite = isfinite # exports -const PREFIXES = ["SCIP", "BMS_"] +const PREFIXES = ["SCIP_", "SCIP", "BMS_"] for name in names(@__MODULE__; all=true), prefix in PREFIXES if startswith(string(name), prefix) @eval export $name From f1df08b341ca9fbf3ebf0d830a544a65778e4361 Mon Sep 17 00:00:00 2001 From: matbesancon Date: Thu, 8 Jan 2026 13:32:45 +0100 Subject: [PATCH 3/3] format --- src/LibSCIP.jl | 70952 ++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 63350 insertions(+), 7602 deletions(-) diff --git a/src/LibSCIP.jl b/src/LibSCIP.jl index 71c6ffb2..30c00a89 100644 --- a/src/LibSCIP.jl +++ b/src/LibSCIP.jl @@ -11,7 +11,6 @@ const SIZE_MAX = typemax(Csize_t) const UINT64_C = UInt64 const UINT32_C = UInt32 - @enum SCIP_Retcode::Int32 begin SCIP_OKAY = 1 SCIP_ERROR = 0 @@ -257,7 +256,7 @@ const SCIP_Rational = Cvoid const SCIP_RATIONAL = SCIP_Rational struct __JL_Ctag_87 - data::NTuple{8, UInt8} + data::NTuple{8,UInt8} end function Base.getproperty(x::Ptr{__JL_Ctag_87}, f::Symbol) @@ -283,12 +282,22 @@ function Base.setproperty!(x::Ptr{__JL_Ctag_87}, f::Symbol, v) unsafe_store!(getproperty(x, f), v) end -function Base.propertynames(x::__JL_Ctag_87, private::Bool = false) - (:probingnode, :sibling, :child, :leaf, :junction, :pseudofork, :fork, :subroot, if private +function Base.propertynames(x::__JL_Ctag_87, private::Bool=false) + ( + :probingnode, + :sibling, + :child, + :leaf, + :junction, + :pseudofork, + :fork, + :subroot, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end const SCIP_ConsSetChg = Cvoid @@ -300,7 +309,7 @@ const SCIP_DomChg = Cvoid const SCIP_DOMCHG = SCIP_DomChg struct SCIP_Node - data::NTuple{80, UInt8} + data::NTuple{80,UInt8} end function Base.getproperty(x::Ptr{SCIP_Node}, f::Symbol) @@ -334,12 +343,30 @@ function Base.setproperty!(x::Ptr{SCIP_Node}, f::Symbol, v) unsafe_store!(getproperty(x, f), v) end -function Base.propertynames(x::SCIP_Node, private::Bool = false) - (:number, :lowerbound, :lowerboundexact, :estimate, :data, :parent, :conssetchg, :domchg, :depth, :reoptid, :reopttype, :repropsubtreemark, :active, :cutoff, :reprop, :nodetype, if private +function Base.propertynames(x::SCIP_Node, private::Bool=false) + ( + :number, + :lowerbound, + :lowerboundexact, + :estimate, + :data, + :parent, + :conssetchg, + :domchg, + :depth, + :reoptid, + :reopttype, + :repropsubtreemark, + :active, + :cutoff, + :reprop, + :nodetype, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end const SCIP_NODE = SCIP_Node @@ -503,7 +530,7 @@ const SCIP_Cutsel = Cvoid const SCIP_CUTSEL = SCIP_Cutsel struct SCIP_RowSolVals - data::NTuple{24, UInt8} + data::NTuple{24,UInt8} end function Base.getproperty(x::Ptr{SCIP_RowSolVals}, f::Symbol) @@ -556,18 +583,18 @@ function Base.setproperty!(x::Ptr{SCIP_RowSolVals}, f::Symbol, v) end end -function Base.propertynames(x::SCIP_RowSolVals, private::Bool = false) +function Base.propertynames(x::SCIP_RowSolVals, private::Bool=false) (:dualsol, :activity, :basisstatus, if private - fieldnames(typeof(x)) - else - () - end...) + fieldnames(typeof(x)) + else + () + end...) end const SCIP_ROWSOLVALS = SCIP_RowSolVals struct SCIP_ColSolVals - data::NTuple{24, UInt8} + data::NTuple{24,UInt8} end function Base.getproperty(x::Ptr{SCIP_ColSolVals}, f::Symbol) @@ -620,18 +647,18 @@ function Base.setproperty!(x::Ptr{SCIP_ColSolVals}, f::Symbol, v) end end -function Base.propertynames(x::SCIP_ColSolVals, private::Bool = false) +function Base.propertynames(x::SCIP_ColSolVals, private::Bool=false) (:primsol, :redcost, :basisstatus, if private - fieldnames(typeof(x)) - else - () - end...) + fieldnames(typeof(x)) + else + () + end...) end const SCIP_COLSOLVALS = SCIP_ColSolVals struct SCIP_Col - data::NTuple{280, UInt8} + data::NTuple{280,UInt8} end function Base.getproperty(x::Ptr{SCIP_Col}, f::Symbol) @@ -733,12 +760,66 @@ function Base.setproperty!(x::Ptr{SCIP_Col}, f::Symbol, v) end end -function Base.propertynames(x::SCIP_Col, private::Bool = false) - (:obj, :lb, :ub, :unchangedobj, :lazylb, :lazyub, :flushedobj, :flushedlb, :flushedub, :primsol, :redcost, :farkascoef, :minprimsol, :maxprimsol, :sbdown, :sbup, :sbsolval, :sblpobjval, :sbnode, :obsoletenode, :storedsolvals, :var, :rows, :vals, :validredcostlp, :validfarkaslp, :validsblp, :linkpos, :index, :size, :len, :nlprows, :nunlinked, :lppos, :lpipos, :lpdepth, :sbitlim, :nsbcalls, :age, :var_probindex, :basisstatus, :lprowssorted, :nonlprowssorted, :objchanged, :lbchanged, :ubchanged, :coefchanged, :integral, :impliedintegral, :removable, :sbdownvalid, :sbupvalid, if private +function Base.propertynames(x::SCIP_Col, private::Bool=false) + ( + :obj, + :lb, + :ub, + :unchangedobj, + :lazylb, + :lazyub, + :flushedobj, + :flushedlb, + :flushedub, + :primsol, + :redcost, + :farkascoef, + :minprimsol, + :maxprimsol, + :sbdown, + :sbup, + :sbsolval, + :sblpobjval, + :sbnode, + :obsoletenode, + :storedsolvals, + :var, + :rows, + :vals, + :validredcostlp, + :validfarkaslp, + :validsblp, + :linkpos, + :index, + :size, + :len, + :nlprows, + :nunlinked, + :lppos, + :lpipos, + :lpdepth, + :sbitlim, + :nsbcalls, + :age, + :var_probindex, + :basisstatus, + :lprowssorted, + :nonlprowssorted, + :objchanged, + :lbchanged, + :ubchanged, + :coefchanged, + :integral, + :impliedintegral, + :removable, + :sbdownvalid, + :sbupvalid, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end const SCIP_COL = SCIP_Col @@ -752,7 +833,7 @@ const SCIP_RowExact = Cvoid const SCIP_ROWEXACT = SCIP_RowExact struct SCIP_Row - data::NTuple{320, UInt8} + data::NTuple{320,UInt8} end function Base.getproperty(x::Ptr{SCIP_Row}, f::Symbol) @@ -867,12 +948,79 @@ function Base.setproperty!(x::Ptr{SCIP_Row}, f::Symbol, v) end end -function Base.propertynames(x::SCIP_Row, private::Bool = false) - (:constant, :lhs, :rhs, :flushedlhs, :flushedrhs, :sqrnorm, :sumnorm, :objprod, :maxval, :minval, :dualsol, :activity, :dualfarkas, :pseudoactivity, :minactivity, :maxactivity, :validpsactivitydomchg, :validactivitybdsdomchg, :obsoletenode, :activeinlpcounter, :nlpsaftercreation, :storedsolvals, :origin, :name, :cols, :cols_index, :vals, :linkpos, :eventfilter, :rowexact, :validactivitylp, :index, :size, :len, :nlpcols, :nunlinked, :nuses, :lppos, :lpipos, :lpdepth, :minidx, :maxidx, :numintcols, :numimplintcols, :nummaxval, :numminval, :age, :rank, :fromcutpool, :basisstatus, :lpcolssorted, :nonlpcolssorted, :delaysort, :validminmaxidx, :lhschanged, :rhschanged, :coefchanged, :integral, :_local, :modifiable, :removable, :inglobalcutpool, :normunreliable, :nlocks, :origintype, if private +function Base.propertynames(x::SCIP_Row, private::Bool=false) + ( + :constant, + :lhs, + :rhs, + :flushedlhs, + :flushedrhs, + :sqrnorm, + :sumnorm, + :objprod, + :maxval, + :minval, + :dualsol, + :activity, + :dualfarkas, + :pseudoactivity, + :minactivity, + :maxactivity, + :validpsactivitydomchg, + :validactivitybdsdomchg, + :obsoletenode, + :activeinlpcounter, + :nlpsaftercreation, + :storedsolvals, + :origin, + :name, + :cols, + :cols_index, + :vals, + :linkpos, + :eventfilter, + :rowexact, + :validactivitylp, + :index, + :size, + :len, + :nlpcols, + :nunlinked, + :nuses, + :lppos, + :lpipos, + :lpdepth, + :minidx, + :maxidx, + :numintcols, + :numimplintcols, + :nummaxval, + :numminval, + :age, + :rank, + :fromcutpool, + :basisstatus, + :lpcolssorted, + :nonlpcolssorted, + :delaysort, + :validminmaxidx, + :lhschanged, + :rhschanged, + :coefchanged, + :integral, + :_local, + :modifiable, + :removable, + :inglobalcutpool, + :normunreliable, + :nlocks, + :origintype, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end const SCIP_ROW = SCIP_Row @@ -1099,7 +1247,12 @@ function SCIPintervalHasRoundingControl() end function SCIPintervalSetRoundingMode(roundmode) - ccall((:SCIPintervalSetRoundingMode, libscip), Cvoid, (SCIP_ROUNDMODE,), roundmode) + ccall( + (:SCIPintervalSetRoundingMode, libscip), + Cvoid, + (SCIP_ROUNDMODE,), + roundmode, + ) end function SCIPintervalGetRoundingMode() @@ -1135,199 +1288,598 @@ function SCIPintervalGetSup(interval) end function SCIPintervalSet(resultant, value) - ccall((:SCIPintervalSet, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble), resultant, value) + ccall( + (:SCIPintervalSet, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL}, Cdouble), + resultant, + value, + ) end function SCIPintervalSetRational(resultant, value) - ccall((:SCIPintervalSetRational, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Ptr{SCIP_RATIONAL}), resultant, value) + ccall( + (:SCIPintervalSetRational, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL}, Ptr{SCIP_RATIONAL}), + resultant, + value, + ) end function SCIPintervalSetBounds(resultant, inf, sup) - ccall((:SCIPintervalSetBounds, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble, Cdouble), resultant, inf, sup) + ccall( + (:SCIPintervalSetBounds, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL}, Cdouble, Cdouble), + resultant, + inf, + sup, + ) end function SCIPintervalSetEmpty(resultant) - ccall((:SCIPintervalSetEmpty, libscip), Cvoid, (Ptr{SCIP_INTERVAL},), resultant) + ccall( + (:SCIPintervalSetEmpty, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL},), + resultant, + ) end function SCIPintervalIsEmpty(infinity, operand) - ccall((:SCIPintervalIsEmpty, libscip), Cuint, (Cdouble, SCIP_INTERVAL), infinity, operand) + ccall( + (:SCIPintervalIsEmpty, libscip), + Cuint, + (Cdouble, SCIP_INTERVAL), + infinity, + operand, + ) end function SCIPintervalSetEntire(infinity, resultant) - ccall((:SCIPintervalSetEntire, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}), infinity, resultant) + ccall( + (:SCIPintervalSetEntire, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}), + infinity, + resultant, + ) end function SCIPintervalIsEntire(infinity, operand) - ccall((:SCIPintervalIsEntire, libscip), Cuint, (Cdouble, SCIP_INTERVAL), infinity, operand) + ccall( + (:SCIPintervalIsEntire, libscip), + Cuint, + (Cdouble, SCIP_INTERVAL), + infinity, + operand, + ) end function SCIPintervalIsPositiveInfinity(infinity, operand) - ccall((:SCIPintervalIsPositiveInfinity, libscip), Cuint, (Cdouble, SCIP_INTERVAL), infinity, operand) + ccall( + (:SCIPintervalIsPositiveInfinity, libscip), + Cuint, + (Cdouble, SCIP_INTERVAL), + infinity, + operand, + ) end function SCIPintervalIsNegativeInfinity(infinity, operand) - ccall((:SCIPintervalIsNegativeInfinity, libscip), Cuint, (Cdouble, SCIP_INTERVAL), infinity, operand) + ccall( + (:SCIPintervalIsNegativeInfinity, libscip), + Cuint, + (Cdouble, SCIP_INTERVAL), + infinity, + operand, + ) end function SCIPintervalIsSubsetEQ(infinity, operand1, operand2) - ccall((:SCIPintervalIsSubsetEQ, libscip), Cuint, (Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), infinity, operand1, operand2) + ccall( + (:SCIPintervalIsSubsetEQ, libscip), + Cuint, + (Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + operand1, + operand2, + ) end function SCIPintervalAreDisjoint(operand1, operand2) - ccall((:SCIPintervalAreDisjoint, libscip), Cuint, (SCIP_INTERVAL, SCIP_INTERVAL), operand1, operand2) + ccall( + (:SCIPintervalAreDisjoint, libscip), + Cuint, + (SCIP_INTERVAL, SCIP_INTERVAL), + operand1, + operand2, + ) end function SCIPintervalAreDisjointEps(eps, operand1, operand2) - ccall((:SCIPintervalAreDisjointEps, libscip), Cuint, (Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), eps, operand1, operand2) + ccall( + (:SCIPintervalAreDisjointEps, libscip), + Cuint, + (Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), + eps, + operand1, + operand2, + ) end function SCIPintervalIntersect(resultant, operand1, operand2) - ccall((:SCIPintervalIntersect, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), resultant, operand1, operand2) + ccall( + (:SCIPintervalIntersect, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + resultant, + operand1, + operand2, + ) end function SCIPintervalIntersectEps(resultant, eps, operand1, operand2) - ccall((:SCIPintervalIntersectEps, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), resultant, eps, operand1, operand2) + ccall( + (:SCIPintervalIntersectEps, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL}, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), + resultant, + eps, + operand1, + operand2, + ) end function SCIPintervalUnify(resultant, operand1, operand2) - ccall((:SCIPintervalUnify, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), resultant, operand1, operand2) + ccall( + (:SCIPintervalUnify, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + resultant, + operand1, + operand2, + ) end function SCIPintervalAddInf(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalAddInf, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalAddInf, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalAddSup(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalAddSup, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalAddSup, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalAdd(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalAdd, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalAdd, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalAddScalar(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalAddScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalAddScalar, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalAddVectors(infinity, resultant, length, operand1, operand2) - ccall((:SCIPintervalAddVectors, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{SCIP_INTERVAL}), infinity, resultant, length, operand1, operand2) + ccall( + (:SCIPintervalAddVectors, libscip), + Cvoid, + ( + Cdouble, + Ptr{SCIP_INTERVAL}, + Cint, + Ptr{SCIP_INTERVAL}, + Ptr{SCIP_INTERVAL}, + ), + infinity, + resultant, + length, + operand1, + operand2, + ) end function SCIPintervalSub(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalSub, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalSub, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalSubScalar(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalSubScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalSubScalar, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalMulInf(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalMulInf, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalMulInf, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalMulSup(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalMulSup, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalMulSup, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalMul(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalMul, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalMul, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalMulScalarInf(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalMulScalarInf, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalMulScalarInf, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalMulScalarSup(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalMulScalarSup, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalMulScalarSup, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalMulScalar(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalMulScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalMulScalar, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalDiv(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalDiv, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalDiv, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalDivScalar(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalDivScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalDivScalar, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalScalprod(infinity, resultant, length, operand1, operand2) - ccall((:SCIPintervalScalprod, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{SCIP_INTERVAL}), infinity, resultant, length, operand1, operand2) -end - -function SCIPintervalScalprodScalarsInf(infinity, resultant, length, operand1, operand2) - ccall((:SCIPintervalScalprodScalarsInf, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), infinity, resultant, length, operand1, operand2) -end - -function SCIPintervalScalprodScalarsSup(infinity, resultant, length, operand1, operand2) - ccall((:SCIPintervalScalprodScalarsSup, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), infinity, resultant, length, operand1, operand2) -end - -function SCIPintervalScalprodScalars(infinity, resultant, length, operand1, operand2) - ccall((:SCIPintervalScalprodScalars, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), infinity, resultant, length, operand1, operand2) + ccall( + (:SCIPintervalScalprod, libscip), + Cvoid, + ( + Cdouble, + Ptr{SCIP_INTERVAL}, + Cint, + Ptr{SCIP_INTERVAL}, + Ptr{SCIP_INTERVAL}, + ), + infinity, + resultant, + length, + operand1, + operand2, + ) +end + +function SCIPintervalScalprodScalarsInf( + infinity, + resultant, + length, + operand1, + operand2, +) + ccall( + (:SCIPintervalScalprodScalarsInf, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), + infinity, + resultant, + length, + operand1, + operand2, + ) +end + +function SCIPintervalScalprodScalarsSup( + infinity, + resultant, + length, + operand1, + operand2, +) + ccall( + (:SCIPintervalScalprodScalarsSup, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), + infinity, + resultant, + length, + operand1, + operand2, + ) +end + +function SCIPintervalScalprodScalars( + infinity, + resultant, + length, + operand1, + operand2, +) + ccall( + (:SCIPintervalScalprodScalars, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}), + infinity, + resultant, + length, + operand1, + operand2, + ) end function SCIPintervalSquare(infinity, resultant, operand) - ccall((:SCIPintervalSquare, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalSquare, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalSquareRoot(infinity, resultant, operand) - ccall((:SCIPintervalSquareRoot, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalSquareRoot, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalPower(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalPower, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalPower, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalPowerScalar(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalPowerScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalPowerScalar, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalPowerScalarScalar(resultant, operand1, operand2) - ccall((:SCIPintervalPowerScalarScalar, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble, Cdouble), resultant, operand1, operand2) + ccall( + (:SCIPintervalPowerScalarScalar, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL}, Cdouble, Cdouble), + resultant, + operand1, + operand2, + ) end function SCIPintervalPowerScalarIntegerInf(operand1, operand2) - ccall((:SCIPintervalPowerScalarIntegerInf, libscip), Cdouble, (Cdouble, Cint), operand1, operand2) + ccall( + (:SCIPintervalPowerScalarIntegerInf, libscip), + Cdouble, + (Cdouble, Cint), + operand1, + operand2, + ) end function SCIPintervalPowerScalarIntegerSup(operand1, operand2) - ccall((:SCIPintervalPowerScalarIntegerSup, libscip), Cdouble, (Cdouble, Cint), operand1, operand2) + ccall( + (:SCIPintervalPowerScalarIntegerSup, libscip), + Cdouble, + (Cdouble, Cint), + operand1, + operand2, + ) end function SCIPintervalPowerScalarInteger(resultant, operand1, operand2) - ccall((:SCIPintervalPowerScalarInteger, libscip), Cvoid, (Ptr{SCIP_INTERVAL}, Cdouble, Cint), resultant, operand1, operand2) -end - -function SCIPintervalPowerScalarInverse(infinity, resultant, basedomain, exponent, image) - ccall((:SCIPintervalPowerScalarInverse, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble, SCIP_INTERVAL), infinity, resultant, basedomain, exponent, image) + ccall( + (:SCIPintervalPowerScalarInteger, libscip), + Cvoid, + (Ptr{SCIP_INTERVAL}, Cdouble, Cint), + resultant, + operand1, + operand2, + ) +end + +function SCIPintervalPowerScalarInverse( + infinity, + resultant, + basedomain, + exponent, + image, +) + ccall( + (:SCIPintervalPowerScalarInverse, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble, SCIP_INTERVAL), + infinity, + resultant, + basedomain, + exponent, + image, + ) end function SCIPintervalSignPowerScalar(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalSignPowerScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalSignPowerScalar, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, Cdouble), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalReciprocal(infinity, resultant, operand) - ccall((:SCIPintervalReciprocal, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalReciprocal, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalExp(infinity, resultant, operand) - ccall((:SCIPintervalExp, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalExp, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalLog(infinity, resultant, operand) - ccall((:SCIPintervalLog, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalLog, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalMin(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalMin, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalMin, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalMax(infinity, resultant, operand1, operand2) - ccall((:SCIPintervalMax, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, operand1, operand2) + ccall( + (:SCIPintervalMax, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + operand1, + operand2, + ) end function SCIPintervalAbsMax(interval) @@ -1335,69 +1887,309 @@ function SCIPintervalAbsMax(interval) end function SCIPintervalAbs(infinity, resultant, operand) - ccall((:SCIPintervalAbs, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalAbs, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalSin(infinity, resultant, operand) - ccall((:SCIPintervalSin, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalSin, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalCos(infinity, resultant, operand) - ccall((:SCIPintervalCos, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalCos, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalSign(infinity, resultant, operand) - ccall((:SCIPintervalSign, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalSign, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalEntropy(infinity, resultant, operand) - ccall((:SCIPintervalEntropy, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), infinity, resultant, operand) + ccall( + (:SCIPintervalEntropy, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL), + infinity, + resultant, + operand, + ) end function SCIPintervalQuadUpperBound(infinity, a, b_, x) - ccall((:SCIPintervalQuadUpperBound, libscip), Cdouble, (Cdouble, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), infinity, a, b_, x) + ccall( + (:SCIPintervalQuadUpperBound, libscip), + Cdouble, + (Cdouble, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + a, + b_, + x, + ) end function SCIPintervalQuad(infinity, resultant, sqrcoeff, lincoeff, xrng) - ccall((:SCIPintervalQuad, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, xrng) -end - -function SCIPintervalSolveUnivariateQuadExpressionPositive(infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) - ccall((:SCIPintervalSolveUnivariateQuadExpressionPositive, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) -end - -function SCIPintervalSolveUnivariateQuadExpressionNegative(infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) - ccall((:SCIPintervalSolveUnivariateQuadExpressionNegative, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) -end - -function SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar(infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) - ccall((:SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Cdouble, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) -end - -function SCIPintervalSolveUnivariateQuadExpression(infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) - ccall((:SCIPintervalSolveUnivariateQuadExpression, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, sqrcoeff, lincoeff, rhs, xbnds) -end - -function SCIPintervalQuadBivar(infinity, resultant, ax, ay, axy, bx, by, xbnds, ybnds) - ccall((:SCIPintervalQuadBivar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, ax, ay, axy, bx, by, xbnds, ybnds) -end - -function SCIPintervalSolveBivariateQuadExpressionAllScalar(infinity, resultant, ax, ay, axy, bx, by, rhs, xbnds, ybnds) - ccall((:SCIPintervalSolveBivariateQuadExpressionAllScalar, libscip), Cvoid, (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL, SCIP_INTERVAL), infinity, resultant, ax, ay, axy, bx, by, rhs, xbnds, ybnds) -end - -function SCIPintervalPropagateWeightedSum(infinity, noperands, operands, weights, constant, rhs, resultants, infeasible) - ccall((:SCIPintervalPropagateWeightedSum, libscip), Cint, (Cdouble, Cint, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}, Cdouble, SCIP_INTERVAL, Ptr{SCIP_INTERVAL}, Ptr{Cuint}), infinity, noperands, operands, weights, constant, rhs, resultants, infeasible) + ccall( + (:SCIPintervalQuad, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, SCIP_INTERVAL, SCIP_INTERVAL), + infinity, + resultant, + sqrcoeff, + lincoeff, + xrng, + ) +end + +function SCIPintervalSolveUnivariateQuadExpressionPositive( + infinity, + resultant, + sqrcoeff, + lincoeff, + rhs, + xbnds, +) + ccall( + (:SCIPintervalSolveUnivariateQuadExpressionPositive, libscip), + Cvoid, + ( + Cdouble, + Ptr{SCIP_INTERVAL}, + SCIP_INTERVAL, + SCIP_INTERVAL, + SCIP_INTERVAL, + SCIP_INTERVAL, + ), + infinity, + resultant, + sqrcoeff, + lincoeff, + rhs, + xbnds, + ) +end + +function SCIPintervalSolveUnivariateQuadExpressionNegative( + infinity, + resultant, + sqrcoeff, + lincoeff, + rhs, + xbnds, +) + ccall( + (:SCIPintervalSolveUnivariateQuadExpressionNegative, libscip), + Cvoid, + ( + Cdouble, + Ptr{SCIP_INTERVAL}, + SCIP_INTERVAL, + SCIP_INTERVAL, + SCIP_INTERVAL, + SCIP_INTERVAL, + ), + infinity, + resultant, + sqrcoeff, + lincoeff, + rhs, + xbnds, + ) +end + +function SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar( + infinity, + resultant, + sqrcoeff, + lincoeff, + rhs, + xbnds, +) + ccall( + (:SCIPintervalSolveUnivariateQuadExpressionPositiveAllScalar, libscip), + Cvoid, + (Cdouble, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Cdouble, SCIP_INTERVAL), + infinity, + resultant, + sqrcoeff, + lincoeff, + rhs, + xbnds, + ) +end + +function SCIPintervalSolveUnivariateQuadExpression( + infinity, + resultant, + sqrcoeff, + lincoeff, + rhs, + xbnds, +) + ccall( + (:SCIPintervalSolveUnivariateQuadExpression, libscip), + Cvoid, + ( + Cdouble, + Ptr{SCIP_INTERVAL}, + SCIP_INTERVAL, + SCIP_INTERVAL, + SCIP_INTERVAL, + SCIP_INTERVAL, + ), + infinity, + resultant, + sqrcoeff, + lincoeff, + rhs, + xbnds, + ) +end + +function SCIPintervalQuadBivar( + infinity, + resultant, + ax, + ay, + axy, + bx, + by, + xbnds, + ybnds, +) + ccall( + (:SCIPintervalQuadBivar, libscip), + Cvoid, + ( + Cdouble, + Ptr{SCIP_INTERVAL}, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + SCIP_INTERVAL, + SCIP_INTERVAL, + ), + infinity, + resultant, + ax, + ay, + axy, + bx, + by, + xbnds, + ybnds, + ) +end + +function SCIPintervalSolveBivariateQuadExpressionAllScalar( + infinity, + resultant, + ax, + ay, + axy, + bx, + by, + rhs, + xbnds, + ybnds, +) + ccall( + (:SCIPintervalSolveBivariateQuadExpressionAllScalar, libscip), + Cvoid, + ( + Cdouble, + Ptr{SCIP_INTERVAL}, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + SCIP_INTERVAL, + SCIP_INTERVAL, + SCIP_INTERVAL, + ), + infinity, + resultant, + ax, + ay, + axy, + bx, + by, + rhs, + xbnds, + ybnds, + ) +end + +function SCIPintervalPropagateWeightedSum( + infinity, + noperands, + operands, + weights, + constant, + rhs, + resultants, + infeasible, +) + ccall( + (:SCIPintervalPropagateWeightedSum, libscip), + Cint, + ( + Cdouble, + Cint, + Ptr{SCIP_INTERVAL}, + Ptr{Cdouble}, + Cdouble, + SCIP_INTERVAL, + Ptr{SCIP_INTERVAL}, + Ptr{Cuint}, + ), + infinity, + noperands, + operands, + weights, + constant, + rhs, + resultants, + infeasible, + ) end struct SCIP_EXPRITER_USERDATA - data::NTuple{8, UInt8} + data::NTuple{8,UInt8} end function Base.getproperty(x::Ptr{SCIP_EXPRITER_USERDATA}, f::Symbol) f === :realval && return Ptr{Cdouble}(x + 0) f === :intval && return Ptr{Cint}(x + 0) - f === :intvals && return Ptr{NTuple{2, Cint}}(x + 0) + f === :intvals && return Ptr{NTuple{2,Cint}}(x + 0) f === :uintval && return Ptr{Cuint}(x + 0) f === :ptrval && return Ptr{Ptr{Cvoid}}(x + 0) return getfield(x, f) @@ -1414,12 +2206,19 @@ function Base.setproperty!(x::Ptr{SCIP_EXPRITER_USERDATA}, f::Symbol, v) unsafe_store!(getproperty(x, f), v) end -function Base.propertynames(x::SCIP_EXPRITER_USERDATA, private::Bool = false) - (:realval, :intval, :intvals, :uintval, :ptrval, if private +function Base.propertynames(x::SCIP_EXPRITER_USERDATA, private::Bool=false) + ( + :realval, + :intval, + :intvals, + :uintval, + :ptrval, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end @enum SCIP_EXPRITER_TYPE::UInt32 begin @@ -1509,7 +2308,7 @@ const SCIP_HYPERGRAPH_EDGE = Cint const SCIP_HYPERGRAPH_VERTEX = Cint struct SCIP_Hypergraph_Iter - data::NTuple{48, UInt8} + data::NTuple{48,UInt8} end function Base.getproperty(x::Ptr{SCIP_Hypergraph_Iter}, f::Symbol) @@ -1571,12 +2370,26 @@ function Base.setproperty!(x::Ptr{SCIP_Hypergraph_Iter}, f::Symbol, v) end end -function Base.propertynames(x::SCIP_Hypergraph_Iter, private::Bool = false) - (:base, :vertexidx, :minvertex, :edgeidx, :adjacent, :ncommonvertices, :sizecommonvertices, :commonvertices, :overlap, :minoverlapsize, :onlylater, :findoverlaps, if private +function Base.propertynames(x::SCIP_Hypergraph_Iter, private::Bool=false) + ( + :base, + :vertexidx, + :minvertex, + :edgeidx, + :adjacent, + :ncommonvertices, + :sizecommonvertices, + :commonvertices, + :overlap, + :minoverlapsize, + :onlylater, + :findoverlaps, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end const SCIP_HYPERGRAPH_ITER = SCIP_Hypergraph_Iter @@ -2953,7 +3766,7 @@ end const SCIP_PSEUDOFORK = SCIP_Pseudofork struct SCIP_Fork - data::NTuple{48, UInt8} + data::NTuple{48,UInt8} end function Base.getproperty(x::Ptr{SCIP_Fork}, f::Symbol) @@ -3015,18 +3828,32 @@ function Base.setproperty!(x::Ptr{SCIP_Fork}, f::Symbol, v) end end -function Base.propertynames(x::SCIP_Fork, private::Bool = false) - (:addedcols, :addedrows, :lpistate, :lpobjval, :naddedcols, :naddedrows, :nlpistateref, :nchildren, :lpwasprimfeas, :lpwasprimchecked, :lpwasdualfeas, :lpwasdualchecked, if private +function Base.propertynames(x::SCIP_Fork, private::Bool=false) + ( + :addedcols, + :addedrows, + :lpistate, + :lpobjval, + :naddedcols, + :naddedrows, + :nlpistateref, + :nchildren, + :lpwasprimfeas, + :lpwasprimchecked, + :lpwasdualfeas, + :lpwasdualchecked, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end const SCIP_FORK = SCIP_Fork struct SCIP_Subroot - data::NTuple{56, UInt8} + data::NTuple{56,UInt8} end function Base.getproperty(x::Ptr{SCIP_Subroot}, f::Symbol) @@ -3088,12 +3915,26 @@ function Base.setproperty!(x::Ptr{SCIP_Subroot}, f::Symbol, v) end end -function Base.propertynames(x::SCIP_Subroot, private::Bool = false) - (:cols, :rows, :lpistate, :lpobjval, :ncols, :nrows, :nlpistateref, :nchildren, :lpwasprimfeas, :lpwasprimchecked, :lpwasdualfeas, :lpwasdualchecked, if private +function Base.propertynames(x::SCIP_Subroot, private::Bool=false) + ( + :cols, + :rows, + :lpistate, + :lpobjval, + :ncols, + :nrows, + :nlpistateref, + :nchildren, + :lpwasprimfeas, + :lpwasprimchecked, + :lpwasdualfeas, + :lpwasdualchecked, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end const SCIP_SUBROOT = SCIP_Subroot @@ -3125,9 +3966,9 @@ struct SCIP_Tree siblings::Ptr{Ptr{SCIP_NODE}} childrenprio::Ptr{Cdouble} siblingsprio::Ptr{Cdouble} - divebdchgvars::NTuple{2, Ptr{Ptr{SCIP_VAR}}} - divebdchgdirs::NTuple{2, Ptr{SCIP_BRANCHDIR}} - divebdchgvals::NTuple{2, Ptr{Cdouble}} + divebdchgvars::NTuple{2,Ptr{Ptr{SCIP_VAR}}} + divebdchgdirs::NTuple{2,Ptr{SCIP_BRANCHDIR}} + divebdchgvals::NTuple{2,Ptr{Cdouble}} pathnlpcols::Ptr{Cint} pathnlprows::Ptr{Cint} probinglpistate::Ptr{SCIP_LPISTATE} @@ -3139,8 +3980,8 @@ struct SCIP_Tree nprobdiverelaxsol::Cint focuslpstateforklpcount::Clonglong lastbranchparentid::Clonglong - divebdchgsize::NTuple{2, Cint} - ndivebdchanges::NTuple{2, Cint} + divebdchgsize::NTuple{2,Cint} + ndivebdchanges::NTuple{2,Cint} pendingbdchgssize::Cint npendingbdchgs::Cint childrensize::Cint @@ -3314,23 +4155,134 @@ const SCIP_Visual = Cvoid const SCIP_VISUAL = SCIP_Visual function SCIPmessagePrintErrorHeader(sourcefile, sourceline) - ccall((:SCIPmessagePrintErrorHeader, libscip), Cvoid, (Ptr{Cchar}, Cint), sourcefile, sourceline) -end - -function SCIPnlpiCreate(nlpi, name, description, priority, nlpicopy, nlpifree, nlpigetsolverpointer, nlpicreateproblem, nlpifreeproblem, nlpigetproblempointer, nlpiaddvars, nlpiaddconstraints, nlpisetobjective, nlpichgvarbounds, nlpichgconssides, nlpidelvarset, nlpidelconsset, nlpichglinearcoefs, nlpichgexpr, nlpichgobjconstant, nlpisetinitialguess, nlpisolve, nlpigetsolstat, nlpigettermstat, nlpigetsolution, nlpigetstatistics, nlpidata) - ccall((:SCIPnlpiCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NLPI}}, Ptr{Cchar}, Ptr{Cchar}, Cint, 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_NLPIDATA}), nlpi, name, description, priority, nlpicopy, nlpifree, nlpigetsolverpointer, nlpicreateproblem, nlpifreeproblem, nlpigetproblempointer, nlpiaddvars, nlpiaddconstraints, nlpisetobjective, nlpichgvarbounds, nlpichgconssides, nlpidelvarset, nlpidelconsset, nlpichglinearcoefs, nlpichgexpr, nlpichgobjconstant, nlpisetinitialguess, nlpisolve, nlpigetsolstat, nlpigettermstat, nlpigetsolution, nlpigetstatistics, nlpidata) + ccall( + (:SCIPmessagePrintErrorHeader, libscip), + Cvoid, + (Ptr{Cchar}, Cint), + sourcefile, + sourceline, + ) +end + +function SCIPnlpiCreate( + nlpi, + name, + description, + priority, + nlpicopy, + nlpifree, + nlpigetsolverpointer, + nlpicreateproblem, + nlpifreeproblem, + nlpigetproblempointer, + nlpiaddvars, + nlpiaddconstraints, + nlpisetobjective, + nlpichgvarbounds, + nlpichgconssides, + nlpidelvarset, + nlpidelconsset, + nlpichglinearcoefs, + nlpichgexpr, + nlpichgobjconstant, + nlpisetinitialguess, + nlpisolve, + nlpigetsolstat, + nlpigettermstat, + nlpigetsolution, + nlpigetstatistics, + nlpidata, +) + ccall( + (:SCIPnlpiCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_NLPI}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + 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_NLPIDATA}, + ), + nlpi, + name, + description, + priority, + nlpicopy, + nlpifree, + nlpigetsolverpointer, + nlpicreateproblem, + nlpifreeproblem, + nlpigetproblempointer, + nlpiaddvars, + nlpiaddconstraints, + nlpisetobjective, + nlpichgvarbounds, + nlpichgconssides, + nlpidelvarset, + nlpidelconsset, + nlpichglinearcoefs, + nlpichgexpr, + nlpichgobjconstant, + nlpisetinitialguess, + nlpisolve, + nlpigetsolstat, + nlpigettermstat, + nlpigetsolution, + nlpigetstatistics, + nlpidata, + ) end function SCIPnlpiSetPriority(nlpi, priority) - ccall((:SCIPnlpiSetPriority, libscip), Cvoid, (Ptr{SCIP_NLPI}, Cint), nlpi, priority) + ccall( + (:SCIPnlpiSetPriority, libscip), + Cvoid, + (Ptr{SCIP_NLPI}, Cint), + nlpi, + priority, + ) end function SCIPnlpiCopyInclude(sourcenlpi, targetset) - ccall((:SCIPnlpiCopyInclude, libscip), SCIP_RETCODE, (Ptr{SCIP_NLPI}, Ptr{SCIP_SET}), sourcenlpi, targetset) + ccall( + (:SCIPnlpiCopyInclude, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NLPI}, Ptr{SCIP_SET}), + sourcenlpi, + targetset, + ) end function SCIPnlpiFree(nlpi, set) - ccall((:SCIPnlpiFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NLPI}}, Ptr{SCIP_SET}), nlpi, set) + ccall( + (:SCIPnlpiFree, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_NLPI}}, Ptr{SCIP_SET}), + nlpi, + set, + ) end function SCIPnlpiInit(nlpi) @@ -3338,123 +4290,516 @@ function SCIPnlpiInit(nlpi) end function SCIPnlpiGetSolverPointer(set, nlpi, problem) - ccall((:SCIPnlpiGetSolverPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), set, nlpi, problem) + ccall( + (:SCIPnlpiGetSolverPointer, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), + set, + nlpi, + problem, + ) end function SCIPnlpiCreateProblem(set, nlpi, problem, name) - ccall((:SCIPnlpiCreateProblem, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}), set, nlpi, problem, name) + ccall( + (:SCIPnlpiCreateProblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}), + set, + nlpi, + problem, + name, + ) end function SCIPnlpiFreeProblem(set, nlpi, problem) - ccall((:SCIPnlpiFreeProblem, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), set, nlpi, problem) + ccall( + (:SCIPnlpiFreeProblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), + set, + nlpi, + problem, + ) end function SCIPnlpiGetProblemPointer(set, nlpi, problem) - ccall((:SCIPnlpiGetProblemPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), set, nlpi, problem) + ccall( + (:SCIPnlpiGetProblemPointer, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), + set, + nlpi, + problem, + ) end function SCIPnlpiAddVars(set, nlpi, problem, nvars, lbs, ubs, varnames) - ccall((:SCIPnlpiAddVars, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), set, nlpi, problem, nvars, lbs, ubs, varnames) -end - -function SCIPnlpiAddConstraints(set, nlpi, problem, nconss, lhss, rhss, nlininds, lininds, linvals, exprs, names) - ccall((:SCIPnlpiAddConstraints, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Ptr{Cchar}}), set, nlpi, problem, nconss, lhss, rhss, nlininds, lininds, linvals, exprs, names) -end - -function SCIPnlpiSetObjective(set, nlpi, problem, nlins, lininds, linvals, expr, constant) - ccall((:SCIPnlpiSetObjective, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_EXPR}, Cdouble), set, nlpi, problem, nlins, lininds, linvals, expr, constant) + ccall( + (:SCIPnlpiAddVars, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Ptr{Cchar}}, + ), + set, + nlpi, + problem, + nvars, + lbs, + ubs, + varnames, + ) +end + +function SCIPnlpiAddConstraints( + set, + nlpi, + problem, + nconss, + lhss, + rhss, + nlininds, + lininds, + linvals, + exprs, + names, +) + ccall( + (:SCIPnlpiAddConstraints, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Ptr{Cchar}}, + ), + set, + nlpi, + problem, + nconss, + lhss, + rhss, + nlininds, + lininds, + linvals, + exprs, + names, + ) +end + +function SCIPnlpiSetObjective( + set, + nlpi, + problem, + nlins, + lininds, + linvals, + expr, + constant, +) + ccall( + (:SCIPnlpiSetObjective, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{SCIP_EXPR}, + Cdouble, + ), + set, + nlpi, + problem, + nlins, + lininds, + linvals, + expr, + constant, + ) end function SCIPnlpiChgVarBounds(set, nlpi, problem, nvars, indices, lbs, ubs) - ccall((:SCIPnlpiChgVarBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), set, nlpi, problem, nvars, indices, lbs, ubs) + ccall( + (:SCIPnlpiChgVarBounds, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + set, + nlpi, + problem, + nvars, + indices, + lbs, + ubs, + ) end function SCIPnlpiChgConsSides(set, nlpi, problem, nconss, indices, lhss, rhss) - ccall((:SCIPnlpiChgConsSides, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), set, nlpi, problem, nconss, indices, lhss, rhss) + ccall( + (:SCIPnlpiChgConsSides, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + set, + nlpi, + problem, + nconss, + indices, + lhss, + rhss, + ) end function SCIPnlpiDelVarSet(set, nlpi, problem, dstats, dstatssize) - ccall((:SCIPnlpiDelVarSet, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), set, nlpi, problem, dstats, dstatssize) + ccall( + (:SCIPnlpiDelVarSet, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), + set, + nlpi, + problem, + dstats, + dstatssize, + ) end function SCIPnlpiDelConsSet(set, nlpi, problem, dstats, dstatssize) - ccall((:SCIPnlpiDelConsSet, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), set, nlpi, problem, dstats, dstatssize) + ccall( + (:SCIPnlpiDelConsSet, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), + set, + nlpi, + problem, + dstats, + dstatssize, + ) end function SCIPnlpiChgLinearCoefs(set, nlpi, problem, idx, nvals, varidxs, vals) - ccall((:SCIPnlpiChgLinearCoefs, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Cint, Ptr{Cint}, Ptr{Cdouble}), set, nlpi, problem, idx, nvals, varidxs, vals) + ccall( + (:SCIPnlpiChgLinearCoefs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + ), + set, + nlpi, + problem, + idx, + nvals, + varidxs, + vals, + ) end function SCIPnlpiChgExpr(set, nlpi, problem, idxcons, expr) - ccall((:SCIPnlpiChgExpr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{SCIP_EXPR}), set, nlpi, problem, idxcons, expr) + ccall( + (:SCIPnlpiChgExpr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{SCIP_EXPR}, + ), + set, + nlpi, + problem, + idxcons, + expr, + ) end function SCIPnlpiChgObjConstant(set, nlpi, problem, objconstant) - ccall((:SCIPnlpiChgObjConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cdouble), set, nlpi, problem, objconstant) -end - -function SCIPnlpiSetInitialGuess(set, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues) - ccall((:SCIPnlpiSetInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), set, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues) + ccall( + (:SCIPnlpiChgObjConstant, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cdouble), + set, + nlpi, + problem, + objconstant, + ) +end + +function SCIPnlpiSetInitialGuess( + set, + nlpi, + problem, + primalvalues, + consdualvalues, + varlbdualvalues, + varubdualvalues, +) + ccall( + (:SCIPnlpiSetInitialGuess, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + set, + nlpi, + problem, + primalvalues, + consdualvalues, + varlbdualvalues, + varubdualvalues, + ) end function SCIPnlpiSolve(set, stat, nlpi, problem, param) - ccall((:SCIPnlpiSolve, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_NLPPARAM}), set, stat, nlpi, problem, param) + ccall( + (:SCIPnlpiSolve, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Ptr{SCIP_NLPPARAM}, + ), + set, + stat, + nlpi, + problem, + param, + ) end function SCIPnlpiGetSolstat(set, nlpi, problem) - ccall((:SCIPnlpiGetSolstat, libscip), SCIP_NLPSOLSTAT, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), set, nlpi, problem) + ccall( + (:SCIPnlpiGetSolstat, libscip), + SCIP_NLPSOLSTAT, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), + set, + nlpi, + problem, + ) end function SCIPnlpiGetTermstat(set, nlpi, problem) - ccall((:SCIPnlpiGetTermstat, libscip), SCIP_NLPTERMSTAT, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), set, nlpi, problem) -end - -function SCIPnlpiGetSolution(set, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) - ccall((:SCIPnlpiGetSolution, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}), set, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) + ccall( + (:SCIPnlpiGetTermstat, libscip), + SCIP_NLPTERMSTAT, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), + set, + nlpi, + problem, + ) +end + +function SCIPnlpiGetSolution( + set, + nlpi, + problem, + primalvalues, + consdualvalues, + varlbdualvalues, + varubdualvalues, + objval, +) + ccall( + (:SCIPnlpiGetSolution, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + Ptr{Cdouble}, + ), + set, + nlpi, + problem, + primalvalues, + consdualvalues, + varlbdualvalues, + varubdualvalues, + objval, + ) end function SCIPnlpiGetStatistics(set, nlpi, problem, statistics) - ccall((:SCIPnlpiGetStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_NLPSTATISTICS}), set, nlpi, problem, statistics) + ccall( + (:SCIPnlpiGetStatistics, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Ptr{SCIP_NLPSTATISTICS}, + ), + set, + nlpi, + problem, + statistics, + ) end function BMSallocMemory_call(size, filename, line) - ccall((:BMSallocMemory_call, libscip), Ptr{Cvoid}, (Csize_t, Ptr{Cchar}, Cint), size, filename, line) + ccall( + (:BMSallocMemory_call, libscip), + Ptr{Cvoid}, + (Csize_t, Ptr{Cchar}, Cint), + size, + filename, + line, + ) end function BMSallocClearMemory_call(num, typesize, filename, line) - ccall((:BMSallocClearMemory_call, libscip), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{Cchar}, Cint), num, typesize, filename, line) + ccall( + (:BMSallocClearMemory_call, libscip), + Ptr{Cvoid}, + (Csize_t, Csize_t, Ptr{Cchar}, Cint), + num, + typesize, + filename, + line, + ) end function BMSallocMemoryArray_call(num, typesize, filename, line) - ccall((:BMSallocMemoryArray_call, libscip), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{Cchar}, Cint), num, typesize, filename, line) + ccall( + (:BMSallocMemoryArray_call, libscip), + Ptr{Cvoid}, + (Csize_t, Csize_t, Ptr{Cchar}, Cint), + num, + typesize, + filename, + line, + ) end function BMSreallocMemoryArray_call(ptr, num, typesize, filename, line) - ccall((:BMSreallocMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), ptr, num, typesize, filename, line) + ccall( + (:BMSreallocMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + ptr, + num, + typesize, + filename, + line, + ) end function BMSreallocMemory_call(ptr, size, filename, line) - ccall((:BMSreallocMemory_call, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), ptr, size, filename, line) + ccall( + (:BMSreallocMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), + ptr, + size, + filename, + line, + ) end function BMSduplicateMemory_call(source, size, filename, line) - ccall((:BMSduplicateMemory_call, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), source, size, filename, line) + ccall( + (:BMSduplicateMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), + source, + size, + filename, + line, + ) end function BMSduplicateMemoryArray_call(source, num, typesize, filename, line) - ccall((:BMSduplicateMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), source, num, typesize, filename, line) + ccall( + (:BMSduplicateMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + source, + num, + typesize, + filename, + line, + ) end function BMSfreeMemory_call(ptr, filename, line) - ccall((:BMSfreeMemory_call, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), ptr, filename, line) + ccall( + (:BMSfreeMemory_call, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), + ptr, + filename, + line, + ) end function BMSfreeMemoryNull_call(ptr, filename, line) - ccall((:BMSfreeMemoryNull_call, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), ptr, filename, line) + ccall( + (:BMSfreeMemoryNull_call, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), + ptr, + filename, + line, + ) end function BMSallocBlockMemory_call(blkmem, size, filename, line) - ccall((:BMSallocBlockMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Csize_t, Ptr{Cchar}, Cint), blkmem, size, filename, line) + ccall( + (:BMSallocBlockMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BLKMEM}, Csize_t, Ptr{Cchar}, Cint), + blkmem, + size, + filename, + line, + ) end function SCIPblkmem(scip) @@ -3462,47 +4807,190 @@ function SCIPblkmem(scip) end function BMSallocClearBlockMemory_call(blkmem, size, filename, line) - ccall((:BMSallocClearBlockMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Csize_t, Ptr{Cchar}, Cint), blkmem, size, filename, line) + ccall( + (:BMSallocClearBlockMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BLKMEM}, Csize_t, Ptr{Cchar}, Cint), + blkmem, + size, + filename, + line, + ) end function BMSallocBlockMemoryArray_call(blkmem, num, typesize, filename, line) - ccall((:BMSallocBlockMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, num, typesize, filename, line) -end - -function BMSallocClearBlockMemoryArray_call(blkmem, num, typesize, filename, line) - ccall((:BMSallocClearBlockMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, num, typesize, filename, line) -end - -function BMSreallocBlockMemoryArray_call(blkmem, ptr, oldnum, newnum, typesize, filename, line) - ccall((:BMSreallocBlockMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, ptr, oldnum, newnum, typesize, filename, line) -end - -function BMSreallocBlockMemory_call(blkmem, ptr, oldsize, newsize, filename, line) - ccall((:BMSreallocBlockMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, ptr, oldsize, newsize, filename, line) + ccall( + (:BMSallocBlockMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BLKMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + blkmem, + num, + typesize, + filename, + line, + ) +end + +function BMSallocClearBlockMemoryArray_call( + blkmem, + num, + typesize, + filename, + line, +) + ccall( + (:BMSallocClearBlockMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BLKMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + blkmem, + num, + typesize, + filename, + line, + ) +end + +function BMSreallocBlockMemoryArray_call( + blkmem, + ptr, + oldnum, + newnum, + typesize, + filename, + line, +) + ccall( + (:BMSreallocBlockMemoryArray_call, libscip), + Ptr{Cvoid}, + ( + Ptr{BMS_BLKMEM}, + Ptr{Cvoid}, + Csize_t, + Csize_t, + Csize_t, + Ptr{Cchar}, + Cint, + ), + blkmem, + ptr, + oldnum, + newnum, + typesize, + filename, + line, + ) +end + +function BMSreallocBlockMemory_call( + blkmem, + ptr, + oldsize, + newsize, + filename, + line, +) + ccall( + (:BMSreallocBlockMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + blkmem, + ptr, + oldsize, + newsize, + filename, + line, + ) end function BMSduplicateBlockMemory_call(blkmem, source, size, filename, line) - ccall((:BMSduplicateBlockMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), blkmem, source, size, filename, line) -end - -function BMSduplicateBlockMemoryArray_call(blkmem, source, num, typesize, filename, line) - ccall((:BMSduplicateBlockMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), blkmem, source, num, typesize, filename, line) -end - -function SCIPensureBlockMemoryArray_call(scip, arrayptr, elemsize, arraysize, minsize) - ccall((:SCIPensureBlockMemoryArray_call, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cint}, Cint), scip, arrayptr, elemsize, arraysize, minsize) + ccall( + (:BMSduplicateBlockMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), + blkmem, + source, + size, + filename, + line, + ) +end + +function BMSduplicateBlockMemoryArray_call( + blkmem, + source, + num, + typesize, + filename, + line, +) + ccall( + (:BMSduplicateBlockMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BLKMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + blkmem, + source, + num, + typesize, + filename, + line, + ) +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 BMSfreeBlockMemory_call(blkmem, ptr, size, filename, line) - ccall((:BMSfreeBlockMemory_call, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), blkmem, ptr, size, filename, line) + ccall( + (:BMSfreeBlockMemory_call, libscip), + Cvoid, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), + blkmem, + ptr, + size, + filename, + line, + ) end function BMSfreeBlockMemoryNull_call(blkmem, ptr, size, filename, line) - ccall((:BMSfreeBlockMemoryNull_call, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), blkmem, ptr, size, filename, line) + ccall( + (:BMSfreeBlockMemoryNull_call, libscip), + Cvoid, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), + blkmem, + ptr, + size, + filename, + line, + ) end function BMSallocBufferMemory_call(buffer, size, filename, line) - ccall((:BMSallocBufferMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Csize_t, Ptr{Cchar}, Cint), buffer, size, filename, line) + ccall( + (:BMSallocBufferMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BUFMEM}, Csize_t, Ptr{Cchar}, Cint), + buffer, + size, + filename, + line, + ) end function SCIPbuffer(scip) @@ -3510,31 +4998,114 @@ function SCIPbuffer(scip) end function BMSallocBufferMemoryArray_call(buffer, num, typesize, filename, line) - ccall((:BMSallocBufferMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), buffer, num, typesize, filename, line) -end - -function BMSallocClearBufferMemoryArray_call(buffer, num, typesize, filename, line) - ccall((:BMSallocClearBufferMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), buffer, num, typesize, filename, line) -end - -function BMSreallocBufferMemoryArray_call(buffer, ptr, num, typesize, filename, line) - ccall((:BMSreallocBufferMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), buffer, ptr, num, typesize, filename, line) + ccall( + (:BMSallocBufferMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BUFMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + buffer, + num, + typesize, + filename, + line, + ) +end + +function BMSallocClearBufferMemoryArray_call( + buffer, + num, + typesize, + filename, + line, +) + ccall( + (:BMSallocClearBufferMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BUFMEM}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + buffer, + num, + typesize, + filename, + line, + ) +end + +function BMSreallocBufferMemoryArray_call( + buffer, + ptr, + num, + typesize, + filename, + line, +) + ccall( + (:BMSreallocBufferMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + buffer, + ptr, + num, + typesize, + filename, + line, + ) end function BMSduplicateBufferMemory_call(buffer, source, size, filename, line) - ccall((:BMSduplicateBufferMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), buffer, source, size, filename, line) -end - -function BMSduplicateBufferMemoryArray_call(buffer, source, num, typesize, filename, line) - ccall((:BMSduplicateBufferMemoryArray_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), buffer, source, num, typesize, filename, line) + ccall( + (:BMSduplicateBufferMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), + buffer, + source, + size, + filename, + line, + ) +end + +function BMSduplicateBufferMemoryArray_call( + buffer, + source, + num, + typesize, + filename, + line, +) + ccall( + (:BMSduplicateBufferMemoryArray_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Csize_t, Ptr{Cchar}, Cint), + buffer, + source, + num, + typesize, + filename, + line, + ) end function BMSfreeBufferMemory_call(buffer, ptr, filename, line) - ccall((:BMSfreeBufferMemory_call, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), buffer, ptr, filename, line) + ccall( + (:BMSfreeBufferMemory_call, libscip), + Cvoid, + (Ptr{BMS_BUFMEM}, Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), + buffer, + ptr, + filename, + line, + ) end function BMSfreeBufferMemoryNull_call(buffer, ptr, filename, line) - ccall((:BMSfreeBufferMemoryNull_call, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), buffer, ptr, filename, line) + ccall( + (:BMSfreeBufferMemoryNull_call, libscip), + Cvoid, + (Ptr{BMS_BUFMEM}, Ptr{Ptr{Cvoid}}, Ptr{Cchar}, Cint), + buffer, + ptr, + filename, + line, + ) end function SCIPcleanbuffer(scip) @@ -3542,71 +5113,276 @@ function SCIPcleanbuffer(scip) end function SCIPsolveNLPParam(scip, param) - ccall((:SCIPsolveNLPParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_NLPPARAM), scip, param) + ccall( + (:SCIPsolveNLPParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, SCIP_NLPPARAM), + scip, + param, + ) end function SCIPsolveNlpiParam(scip, nlpi, problem, param) - ccall((:SCIPsolveNlpiParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, SCIP_NLPPARAM), scip, nlpi, problem, param) + ccall( + (:SCIPsolveNlpiParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, SCIP_NLPPARAM), + scip, + nlpi, + problem, + param, + ) end function BMSreallocBufferMemory_call(buffer, ptr, size, filename, line) - ccall((:BMSreallocBufferMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), buffer, ptr, size, filename, line) + ccall( + (:BMSreallocBufferMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_BUFMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), + buffer, + ptr, + size, + filename, + line, + ) end const SCIP_LPiExact = Cvoid const SCIP_LPIEXACT = SCIP_LPiExact -function SCIPshrinkDisjunctiveVarSet(scip, vars, bounds, boundtypes, redundants, nvars, nredvars, nglobalred, setredundant, glbinfeas, fullshortening) - ccall((:SCIPshrinkDisjunctiveVarSet, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}, Cuint), scip, vars, bounds, boundtypes, redundants, nvars, nredvars, nglobalred, setredundant, glbinfeas, fullshortening) -end - -function SCIPcutsTightenCoefficients(scip, cutislocal, cutcoefs, cutrhs, cutinds, cutnnz, nchgcoefs) - ccall((:SCIPcutsTightenCoefficients, libscip), Cuint, (Ptr{SCIP}, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, cutislocal, cutcoefs, cutrhs, cutinds, cutnnz, nchgcoefs) +function SCIPshrinkDisjunctiveVarSet( + scip, + vars, + bounds, + boundtypes, + redundants, + nvars, + nredvars, + nglobalred, + setredundant, + glbinfeas, + fullshortening, +) + ccall( + (:SCIPshrinkDisjunctiveVarSet, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Cint, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cuint}, + Cuint, + ), + scip, + vars, + bounds, + boundtypes, + redundants, + nvars, + nredvars, + nglobalred, + setredundant, + glbinfeas, + fullshortening, + ) +end + +function SCIPcutsTightenCoefficients( + scip, + cutislocal, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + nchgcoefs, +) + ccall( + (:SCIPcutsTightenCoefficients, libscip), + Cuint, + ( + Ptr{SCIP}, + Cuint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + cutislocal, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + nchgcoefs, + ) end function SCIPaggrRowCreate(scip, aggrrow) - ccall((:SCIPaggrRowCreate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}), scip, aggrrow) + ccall( + (:SCIPaggrRowCreate, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}), + scip, + aggrrow, + ) end function SCIPaggrRowFree(scip, aggrrow) - ccall((:SCIPaggrRowFree, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}), scip, aggrrow) + ccall( + (:SCIPaggrRowFree, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}), + scip, + aggrrow, + ) end function SCIPaggrRowPrint(scip, aggrrow, file) - ccall((:SCIPaggrRowPrint, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Libc.FILE}), scip, aggrrow, file) + ccall( + (:SCIPaggrRowPrint, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Libc.FILE}), + scip, + aggrrow, + file, + ) end function SCIPaggrRowCopy(scip, aggrrow, source) - ccall((:SCIPaggrRowCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}, Ptr{SCIP_AGGRROW}), scip, aggrrow, source) + ccall( + (:SCIPaggrRowCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_AGGRROW}}, Ptr{SCIP_AGGRROW}), + scip, + aggrrow, + source, + ) end function SCIPaggrRowAddRow(scip, aggrrow, row, weight, sidetype) - ccall((:SCIPaggrRowAddRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}, Cdouble, Cint), scip, aggrrow, row, weight, sidetype) + ccall( + (:SCIPaggrRowAddRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}, Cdouble, Cint), + scip, + aggrrow, + row, + weight, + sidetype, + ) end function SCIPaggrRowAddRowSafely(scip, aggrrow, row, weight, sidetype, success) - ccall((:SCIPaggrRowAddRowSafely, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}, Cdouble, Cint, Ptr{Cuint}), scip, aggrrow, row, weight, sidetype, success) + ccall( + (:SCIPaggrRowAddRowSafely, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_AGGRROW}, + Ptr{SCIP_ROW}, + Cdouble, + Cint, + Ptr{Cuint}, + ), + scip, + aggrrow, + row, + weight, + sidetype, + success, + ) end function SCIPaggrRowCancelVarWithBound(scip, aggrrow, var, pos, valid) - ccall((:SCIPaggrRowCancelVarWithBound, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_VAR}, Cint, Ptr{Cuint}), scip, aggrrow, var, pos, valid) + ccall( + (:SCIPaggrRowCancelVarWithBound, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{SCIP_VAR}, Cint, Ptr{Cuint}), + scip, + aggrrow, + var, + pos, + valid, + ) end function SCIPaggrRowAddObjectiveFunction(scip, aggrrow, rhs, scale) - ccall((:SCIPaggrRowAddObjectiveFunction, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cdouble, Cdouble), scip, aggrrow, rhs, scale) + ccall( + (:SCIPaggrRowAddObjectiveFunction, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cdouble, Cdouble), + scip, + aggrrow, + rhs, + scale, + ) end function SCIPaggrRowAddObjectiveFunctionSafely(scip, aggrrow, rhs, scale) - ccall((:SCIPaggrRowAddObjectiveFunctionSafely, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cdouble, Cdouble), scip, aggrrow, rhs, scale) -end - -function SCIPaggrRowAddCustomCons(scip, aggrrow, inds, vals, len, rhs, weight, rank, _local) - ccall((:SCIPaggrRowAddCustomCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Cint}, Ptr{Cdouble}, Cint, Cdouble, Cdouble, Cint, Cuint), scip, aggrrow, inds, vals, len, rhs, weight, rank, _local) + ccall( + (:SCIPaggrRowAddObjectiveFunctionSafely, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cdouble, Cdouble), + scip, + aggrrow, + rhs, + scale, + ) +end + +function SCIPaggrRowAddCustomCons( + scip, + aggrrow, + inds, + vals, + len, + rhs, + weight, + rank, + _local, +) + ccall( + (:SCIPaggrRowAddCustomCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_AGGRROW}, + Ptr{Cint}, + Ptr{Cdouble}, + Cint, + Cdouble, + Cdouble, + Cint, + Cuint, + ), + scip, + aggrrow, + inds, + vals, + len, + rhs, + weight, + rank, + _local, + ) end function SCIPaggrRowCalcEfficacyNorm(scip, aggrrow) - ccall((:SCIPaggrRowCalcEfficacyNorm, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}), scip, aggrrow) + ccall( + (:SCIPaggrRowCalcEfficacyNorm, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_AGGRROW}), + scip, + aggrrow, + ) end function SCIPaggrRowClear(aggrrow) @@ -3614,35 +5390,112 @@ function SCIPaggrRowClear(aggrrow) end function SCIPaggrRowClearSafely(aggrrow) - ccall((:SCIPaggrRowClearSafely, libscip), Cvoid, (Ptr{SCIP_AGGRROW},), aggrrow) -end - -function SCIPaggrRowSumRows(scip, aggrrow, weights, rowinds, nrowinds, sidetypebasis, allowlocal, negslack, maxaggrlen, valid) - ccall((:SCIPaggrRowSumRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cuint, Cuint, Cint, Cint, Ptr{Cuint}), scip, aggrrow, weights, rowinds, nrowinds, sidetypebasis, allowlocal, negslack, maxaggrlen, valid) + ccall( + (:SCIPaggrRowClearSafely, libscip), + Cvoid, + (Ptr{SCIP_AGGRROW},), + aggrrow, + ) +end + +function SCIPaggrRowSumRows( + scip, + aggrrow, + weights, + rowinds, + nrowinds, + sidetypebasis, + allowlocal, + negslack, + maxaggrlen, + valid, +) + ccall( + (:SCIPaggrRowSumRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_AGGRROW}, + Ptr{Cdouble}, + Ptr{Cint}, + Cint, + Cuint, + Cuint, + Cint, + Cint, + Ptr{Cuint}, + ), + scip, + aggrrow, + weights, + rowinds, + nrowinds, + sidetypebasis, + allowlocal, + negslack, + maxaggrlen, + valid, + ) end function SCIPaggrRowRemoveZeros(scip, aggrrow, useglbbounds, valid) - ccall((:SCIPaggrRowRemoveZeros, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cuint, Ptr{Cuint}), scip, aggrrow, useglbbounds, valid) + ccall( + (:SCIPaggrRowRemoveZeros, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Cuint, Ptr{Cuint}), + scip, + aggrrow, + useglbbounds, + valid, + ) end function SCIPaggrRowGetRowInds(aggrrow) - ccall((:SCIPaggrRowGetRowInds, libscip), Ptr{Cint}, (Ptr{SCIP_AGGRROW},), aggrrow) + ccall( + (:SCIPaggrRowGetRowInds, libscip), + Ptr{Cint}, + (Ptr{SCIP_AGGRROW},), + aggrrow, + ) end function SCIPaggrRowGetRowWeights(aggrrow) - ccall((:SCIPaggrRowGetRowWeights, libscip), Ptr{Cdouble}, (Ptr{SCIP_AGGRROW},), aggrrow) + ccall( + (:SCIPaggrRowGetRowWeights, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_AGGRROW},), + aggrrow, + ) end function SCIPaggrRowHasRowBeenAdded(aggrrow, row) - ccall((:SCIPaggrRowHasRowBeenAdded, libscip), Cuint, (Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}), aggrrow, row) + ccall( + (:SCIPaggrRowHasRowBeenAdded, libscip), + Cuint, + (Ptr{SCIP_AGGRROW}, Ptr{SCIP_ROW}), + aggrrow, + row, + ) end function SCIPaggrRowGetAbsWeightRange(aggrrow, minabsrowweight, maxabsrowweight) - ccall((:SCIPaggrRowGetAbsWeightRange, libscip), Cvoid, (Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}), aggrrow, minabsrowweight, maxabsrowweight) + ccall( + (:SCIPaggrRowGetAbsWeightRange, libscip), + Cvoid, + (Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}), + aggrrow, + minabsrowweight, + maxabsrowweight, + ) end function SCIPaggrRowGetInds(aggrrow) - ccall((:SCIPaggrRowGetInds, libscip), Ptr{Cint}, (Ptr{SCIP_AGGRROW},), aggrrow) + ccall( + (:SCIPaggrRowGetInds, libscip), + Ptr{Cint}, + (Ptr{SCIP_AGGRROW},), + aggrrow, + ) end function SCIPaggrRowGetNNz(aggrrow) @@ -3650,15 +5503,33 @@ function SCIPaggrRowGetNNz(aggrrow) end function SCIPaggrRowGetValue(aggrrow, i) - ccall((:SCIPaggrRowGetValue, libscip), Cdouble, (Ptr{SCIP_AGGRROW}, Cint), aggrrow, i) + ccall( + (:SCIPaggrRowGetValue, libscip), + Cdouble, + (Ptr{SCIP_AGGRROW}, Cint), + aggrrow, + i, + ) end function SCIPaggrRowGetValueSafely(aggrrow, i) - ccall((:SCIPaggrRowGetValueSafely, libscip), Cdouble, (Ptr{SCIP_AGGRROW}, Cint), aggrrow, i) + ccall( + (:SCIPaggrRowGetValueSafely, libscip), + Cdouble, + (Ptr{SCIP_AGGRROW}, Cint), + aggrrow, + i, + ) end function SCIPaggrRowGetProbvarValue(aggrrow, probindex) - ccall((:SCIPaggrRowGetProbvarValue, libscip), Cdouble, (Ptr{SCIP_AGGRROW}, Cint), aggrrow, probindex) + ccall( + (:SCIPaggrRowGetProbvarValue, libscip), + Cdouble, + (Ptr{SCIP_AGGRROW}, Cint), + aggrrow, + probindex, + ) end function SCIPaggrRowGetRank(aggrrow) @@ -3677,116 +5548,759 @@ function SCIPaggrRowGetNRows(aggrrow) ccall((:SCIPaggrRowGetNRows, libscip), Cint, (Ptr{SCIP_AGGRROW},), aggrrow) end -function SCIPcalcMIR(scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, fixintegralrhs, boundsfortrans, boundtypesfortrans, minfrac, maxfrac, scale, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) - ccall((:SCIPcalcMIR, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cdouble, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{SCIP_BOUNDTYPE}, Cdouble, Cdouble, Cdouble, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, fixintegralrhs, boundsfortrans, boundtypesfortrans, minfrac, maxfrac, scale, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) -end - -function SCIPcutGenerationHeuristicCMIR(scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, maxtestdelta, boundsfortrans, boundtypesfortrans, minfrac, maxfrac, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) - ccall((:SCIPcutGenerationHeuristicCMIR, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cdouble, Cint, Cuint, Cint, Ptr{Cint}, Ptr{SCIP_BOUNDTYPE}, Cdouble, Cdouble, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, maxtestdelta, boundsfortrans, boundtypesfortrans, minfrac, maxfrac, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) -end - -function SCIPcalcFlowCover(scip, sol, postprocess, boundswitch, allowlocal, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) - ccall((:SCIPcalcFlowCover, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cdouble, Cuint, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, postprocess, boundswitch, allowlocal, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) -end - -function SCIPcalcKnapsackCover(scip, sol, allowlocal, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) - ccall((:SCIPcalcKnapsackCover, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, allowlocal, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) -end - -function SCIPcalcStrongCG(scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, minfrac, maxfrac, scale, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) - ccall((:SCIPcalcStrongCG, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cdouble, Cint, Cuint, Cdouble, Cdouble, Cdouble, Ptr{SCIP_AGGRROW}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cuint}), scip, sol, postprocess, boundswitch, vartypeusevbds, allowlocal, minfrac, maxfrac, scale, aggrrow, cutcoefs, cutrhs, cutinds, cutnnz, cutefficacy, cutrank, cutislocal, success) -end - -function SCIPperformGenericDivingAlgorithm(scip, diveset, worksol, heur, result, nodeinfeasible, iterlim, nodelimit, lpresolvedomchgquot, divecontext) - ccall((:SCIPperformGenericDivingAlgorithm, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cuint, Clonglong, Cint, Cdouble, SCIP_DIVECONTEXT), scip, diveset, worksol, heur, result, nodeinfeasible, iterlim, nodelimit, lpresolvedomchgquot, divecontext) -end - -function SCIPcopyLargeNeighborhoodSearch(sourcescip, subscip, varmap, suffix, fixedvars, fixedvals, nfixedvars, uselprows, copycuts, success, valid) - ccall((:SCIPcopyLargeNeighborhoodSearch, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint, Cuint, Ptr{Cuint}, Ptr{Cuint}), sourcescip, subscip, varmap, suffix, fixedvars, fixedvals, nfixedvars, uselprows, copycuts, success, valid) -end - -function SCIPaddTrustregionNeighborhoodConstraint(sourcescip, targetscip, subvars, violpenalty) - ccall((:SCIPaddTrustregionNeighborhoodConstraint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cdouble), sourcescip, targetscip, subvars, violpenalty) -end - -function SCIPincludeBanditvtable(scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) - ccall((:SCIPincludeBanditvtable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDITVTABLE}}, Ptr{Cchar}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, banditvtable, name, banditfree, banditselect, banditupdate, banditreset) +function SCIPcalcMIR( + scip, + sol, + postprocess, + boundswitch, + vartypeusevbds, + allowlocal, + fixintegralrhs, + boundsfortrans, + boundtypesfortrans, + minfrac, + maxfrac, + scale, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, +) + ccall( + (:SCIPcalcMIR, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_SOL}, + Cuint, + Cdouble, + Cint, + Cuint, + Cuint, + Ptr{Cint}, + Ptr{SCIP_BOUNDTYPE}, + Cdouble, + Cdouble, + Cdouble, + Ptr{SCIP_AGGRROW}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + sol, + postprocess, + boundswitch, + vartypeusevbds, + allowlocal, + fixintegralrhs, + boundsfortrans, + boundtypesfortrans, + minfrac, + maxfrac, + scale, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, + ) +end + +function SCIPcutGenerationHeuristicCMIR( + scip, + sol, + postprocess, + boundswitch, + vartypeusevbds, + allowlocal, + maxtestdelta, + boundsfortrans, + boundtypesfortrans, + minfrac, + maxfrac, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, +) + ccall( + (:SCIPcutGenerationHeuristicCMIR, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_SOL}, + Cuint, + Cdouble, + Cint, + Cuint, + Cint, + Ptr{Cint}, + Ptr{SCIP_BOUNDTYPE}, + Cdouble, + Cdouble, + Ptr{SCIP_AGGRROW}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + sol, + postprocess, + boundswitch, + vartypeusevbds, + allowlocal, + maxtestdelta, + boundsfortrans, + boundtypesfortrans, + minfrac, + maxfrac, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, + ) +end + +function SCIPcalcFlowCover( + scip, + sol, + postprocess, + boundswitch, + allowlocal, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, +) + ccall( + (:SCIPcalcFlowCover, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_SOL}, + Cuint, + Cdouble, + Cuint, + Ptr{SCIP_AGGRROW}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + sol, + postprocess, + boundswitch, + allowlocal, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, + ) +end + +function SCIPcalcKnapsackCover( + scip, + sol, + allowlocal, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, +) + ccall( + (:SCIPcalcKnapsackCover, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_SOL}, + Cuint, + Ptr{SCIP_AGGRROW}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + sol, + allowlocal, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, + ) +end + +function SCIPcalcStrongCG( + scip, + sol, + postprocess, + boundswitch, + vartypeusevbds, + allowlocal, + minfrac, + maxfrac, + scale, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, +) + ccall( + (:SCIPcalcStrongCG, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_SOL}, + Cuint, + Cdouble, + Cint, + Cuint, + Cdouble, + Cdouble, + Cdouble, + Ptr{SCIP_AGGRROW}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + sol, + postprocess, + boundswitch, + vartypeusevbds, + allowlocal, + minfrac, + maxfrac, + scale, + aggrrow, + cutcoefs, + cutrhs, + cutinds, + cutnnz, + cutefficacy, + cutrank, + cutislocal, + success, + ) +end + +function SCIPperformGenericDivingAlgorithm( + scip, + diveset, + worksol, + heur, + result, + nodeinfeasible, + iterlim, + nodelimit, + lpresolvedomchgquot, + divecontext, +) + ccall( + (:SCIPperformGenericDivingAlgorithm, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIVESET}, + Ptr{SCIP_SOL}, + Ptr{SCIP_HEUR}, + Ptr{SCIP_RESULT}, + Cuint, + Clonglong, + Cint, + Cdouble, + SCIP_DIVECONTEXT, + ), + scip, + diveset, + worksol, + heur, + result, + nodeinfeasible, + iterlim, + nodelimit, + lpresolvedomchgquot, + divecontext, + ) +end + +function SCIPcopyLargeNeighborhoodSearch( + sourcescip, + subscip, + varmap, + suffix, + fixedvars, + fixedvals, + nfixedvars, + uselprows, + copycuts, + success, + valid, +) + ccall( + (:SCIPcopyLargeNeighborhoodSearch, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_HASHMAP}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cint, + Cuint, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + sourcescip, + subscip, + varmap, + suffix, + fixedvars, + fixedvals, + nfixedvars, + uselprows, + copycuts, + success, + valid, + ) +end + +function SCIPaddTrustregionNeighborhoodConstraint( + sourcescip, + targetscip, + subvars, + violpenalty, +) + ccall( + (:SCIPaddTrustregionNeighborhoodConstraint, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cdouble), + sourcescip, + targetscip, + subvars, + violpenalty, + ) +end + +function SCIPincludeBanditvtable( + scip, + banditvtable, + name, + banditfree, + banditselect, + banditupdate, + banditreset, +) + ccall( + (:SCIPincludeBanditvtable, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_BANDITVTABLE}}, + Ptr{Cchar}, + 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}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindBanditvtable, libscip), + Ptr{SCIP_BANDITVTABLE}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPfreeBandit(scip, bandit) - ccall((:SCIPfreeBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}), scip, bandit) + ccall( + (:SCIPfreeBandit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}), + scip, + bandit, + ) end function SCIPresetBandit(scip, bandit, priorities, seed) - ccall((:SCIPresetBandit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BANDIT}, Ptr{Cdouble}, Cuint), scip, bandit, priorities, seed) -end - -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}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, Cuint, Cuint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, Cuint, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_BENDERSDATA}), scip, bendersptr, name, desc, priority, cutlp, cutpseudo, cutrelax, shareauxvars, bendersgetvar, benderscreatesub, bendersdata) + ccall( + (:SCIPresetBandit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BANDIT}, Ptr{Cdouble}, Cuint), + scip, + bandit, + priorities, + seed, + ) +end + +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}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_BENDERSDATA}, + ), + scip, + bendersptr, + name, + desc, + priority, + cutlp, + cutpseudo, + cutrelax, + shareauxvars, + bendersgetvar, + benderscreatesub, + bendersdata, + ) end function SCIPsetBendersCopy(scip, benders, benderscopy) - ccall((:SCIPsetBendersCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderscopy) + ccall( + (:SCIPsetBendersCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + benderscopy, + ) end function SCIPsetBendersFree(scip, benders, bendersfree) - ccall((:SCIPsetBendersFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersfree) + ccall( + (:SCIPsetBendersFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + bendersfree, + ) end function SCIPsetBendersInit(scip, benders, bendersinit) - ccall((:SCIPsetBendersInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinit) + ccall( + (:SCIPsetBendersInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + bendersinit, + ) end function SCIPsetBendersExit(scip, benders, bendersexit) - ccall((:SCIPsetBendersExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexit) + ccall( + (:SCIPsetBendersExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + bendersexit, + ) end function SCIPsetBendersInitpre(scip, benders, bendersinitpre) - ccall((:SCIPsetBendersInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitpre) + ccall( + (:SCIPsetBendersInitpre, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + bendersinitpre, + ) end function SCIPsetBendersExitpre(scip, benders, bendersexitpre) - ccall((:SCIPsetBendersExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitpre) + ccall( + (:SCIPsetBendersExitpre, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + bendersexitpre, + ) end function SCIPsetBendersInitsol(scip, benders, bendersinitsol) - ccall((:SCIPsetBendersInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersinitsol) + ccall( + (:SCIPsetBendersInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + bendersinitsol, + ) end function SCIPsetBendersExitsol(scip, benders, bendersexitsol) - ccall((:SCIPsetBendersExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, bendersexitsol) + ccall( + (:SCIPsetBendersExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + bendersexitsol, + ) end function SCIPsetBendersPresubsolve(scip, benders, benderspresubsolve) - ccall((:SCIPsetBendersPresubsolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderspresubsolve) -end - -function SCIPsetBendersSolveAndFreesub(scip, benders, benderssolvesubconvex, benderssolvesub, bendersfreesub) - ccall((:SCIPsetBendersSolveAndFreesub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, benders, benderssolvesubconvex, benderssolvesub, bendersfreesub) + ccall( + (: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) + ccall( + (:SCIPsetBendersPostsolve, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + benderspostsolve, + ) end function SCIPsetBendersSubproblemComp(scip, benders, benderssubcomp) - ccall((:SCIPsetBendersSubproblemComp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), scip, benders, benderssubcomp) + ccall( + (:SCIPsetBendersSubproblemComp, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Cvoid}), + scip, + benders, + benderssubcomp, + ) end function SCIPfindBenders(scip, name) - ccall((:SCIPfindBenders, libscip), Ptr{SCIP_BENDERS}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindBenders, libscip), + Ptr{SCIP_BENDERS}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetBenders(scip) - ccall((:SCIPgetBenders, libscip), Ptr{Ptr{SCIP_BENDERS}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetBenders, libscip), + Ptr{Ptr{SCIP_BENDERS}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNBenders(scip) @@ -3798,163 +6312,671 @@ function SCIPgetNActiveBenders(scip) end function SCIPactivateBenders(scip, benders, nsubproblems) - ccall((:SCIPactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, nsubproblems) + ccall( + (:SCIPactivateBenders, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), + scip, + benders, + nsubproblems, + ) end function SCIPdeactivateBenders(scip, benders) - ccall((:SCIPdeactivateBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) + ccall( + (:SCIPdeactivateBenders, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}), + scip, + benders, + ) end function SCIPsetBendersPriority(scip, benders, priority) - ccall((:SCIPsetBendersPriority, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), scip, benders, priority) + ccall( + (:SCIPsetBendersPriority, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint), + scip, + benders, + priority, + ) end function SCIPsetBendersObjectiveType(scip, benders, objectivetype) - ccall((:SCIPsetBendersObjectiveType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, SCIP_BENDERSOBJTYPE), scip, benders, objectivetype) -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{Cuint}, Ptr{Cuint}, SCIP_BENDERSENFOTYPE, Cuint), scip, benders, sol, result, infeasible, auxviol, type, checkint) + ccall( + (:SCIPsetBendersObjectiveType, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, SCIP_BENDERSOBJTYPE), + scip, + benders, + objectivetype, + ) +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{Cuint}, + Ptr{Cuint}, + SCIP_BENDERSENFOTYPE, + Cuint, + ), + scip, + benders, + sol, + result, + infeasible, + auxviol, + type, + checkint, + ) end function SCIPgetBendersMasterVar(scip, benders, var, mappedvar) - ccall((:SCIPgetBendersMasterVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, benders, var, mappedvar) + ccall( + (:SCIPgetBendersMasterVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), + scip, + benders, + var, + mappedvar, + ) end function SCIPgetBendersSubproblemVar(scip, benders, var, mappedvar, probnumber) - ccall((:SCIPgetBendersSubproblemVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, benders, var, mappedvar, probnumber) + ccall( + (:SCIPgetBendersSubproblemVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Cint), + scip, + benders, + var, + mappedvar, + probnumber, + ) end function SCIPgetBendersNSubproblems(scip, benders) - ccall((:SCIPgetBendersNSubproblems, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) + ccall( + (:SCIPgetBendersNSubproblems, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}), + scip, + benders, + ) end function SCIPaddBendersSubproblem(scip, benders, subproblem) - ccall((:SCIPaddBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP}), scip, benders, subproblem) + ccall( + (:SCIPaddBendersSubproblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP}), + scip, + benders, + subproblem, + ) end function SCIPsetupBendersSubproblem(scip, benders, sol, probnumber, type) - ccall((:SCIPsetupBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, SCIP_BENDERSENFOTYPE), scip, benders, sol, probnumber, type) -end - -function SCIPsolveBendersSubproblem(scip, benders, sol, probnumber, infeasible, solvecip, objective) - ccall((:SCIPsolveBendersSubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{SCIP_SOL}, Cint, Ptr{Cuint}, Cuint, Ptr{Cdouble}), scip, benders, sol, probnumber, infeasible, solvecip, objective) + ccall( + (:SCIPsetupBendersSubproblem, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_BENDERS}, + Ptr{SCIP_SOL}, + Cint, + SCIP_BENDERSENFOTYPE, + ), + scip, + benders, + sol, + probnumber, + type, + ) +end + +function SCIPsolveBendersSubproblem( + scip, + benders, + sol, + probnumber, + infeasible, + solvecip, + objective, +) + ccall( + (:SCIPsolveBendersSubproblem, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_BENDERS}, + Ptr{SCIP_SOL}, + Cint, + Ptr{Cuint}, + Cuint, + Ptr{Cdouble}, + ), + scip, + benders, + sol, + probnumber, + infeasible, + 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{Cuint}), scip, benders, sol, probnumber, optimal) + 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{Cuint}), + 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{Cuint}), 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}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, Ptr{Cvoid}, Ptr{SCIP_BENDERSCUTDATA}), scip, benders, benderscutptr, name, desc, priority, islpcut, benderscutexec, benderscutdata) + 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{Cuint}), + 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}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cuint, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cuint, + Ptr{Cvoid}, + Ptr{SCIP_BENDERSCUTDATA}, + ), + scip, + benders, + benderscutptr, + name, + desc, + priority, + islpcut, + benderscutexec, + benderscutdata, + ) end function SCIPsetBenderscutCopy(scip, benderscut, benderscutcopy) - ccall((:SCIPsetBenderscutCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutcopy) + ccall( + (:SCIPsetBenderscutCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), + scip, + benderscut, + benderscutcopy, + ) end function SCIPsetBenderscutFree(scip, benderscut, benderscutfree) - ccall((:SCIPsetBenderscutFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutfree) + ccall( + (:SCIPsetBenderscutFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), + scip, + benderscut, + benderscutfree, + ) end function SCIPsetBenderscutInit(scip, benderscut, benderscutinit) - ccall((:SCIPsetBenderscutInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinit) + ccall( + (:SCIPsetBenderscutInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), + scip, + benderscut, + benderscutinit, + ) end function SCIPsetBenderscutExit(scip, benderscut, benderscutexit) - ccall((:SCIPsetBenderscutExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexit) + ccall( + (:SCIPsetBenderscutExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), + scip, + benderscut, + benderscutexit, + ) end function SCIPsetBenderscutInitsol(scip, benderscut, benderscutinitsol) - ccall((:SCIPsetBenderscutInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutinitsol) + ccall( + (:SCIPsetBenderscutInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), + scip, + benderscut, + benderscutinitsol, + ) end function SCIPsetBenderscutExitsol(scip, benderscut, benderscutexitsol) - ccall((:SCIPsetBenderscutExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), scip, benderscut, benderscutexitsol) + ccall( + (:SCIPsetBenderscutExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Ptr{Cvoid}), + scip, + benderscut, + benderscutexitsol, + ) end function SCIPsetBenderscutPriority(scip, benderscut, priority) - ccall((:SCIPsetBenderscutPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Cint), scip, benderscut, priority) + ccall( + (:SCIPsetBenderscutPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERSCUT}, Cint), + scip, + benderscut, + priority, + ) end function SCIPstoreBendersCut(scip, benders, vars, vals, lhs, rhs, nvars) - ccall((:SCIPstoreBendersCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Cint), scip, benders, vars, vals, lhs, rhs, nvars) + ccall( + (:SCIPstoreBendersCut, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_BENDERS}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + Cint, + ), + scip, + benders, + vars, + vals, + lhs, + rhs, + nvars, + ) end function SCIPapplyBendersStoredCuts(scip, benders) - ccall((:SCIPapplyBendersStoredCuts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}), scip, benders) -end - -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}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cdouble, Ptr{SCIP_BRANCHRULEDATA}), scip, branchruleptr, name, desc, priority, maxdepth, maxbounddist, branchruledata) + ccall( + (:SCIPapplyBendersStoredCuts, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}), + scip, + benders, + ) +end + +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}, + Ptr{Cchar}, + Ptr{Cchar}, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Cdouble, + Ptr{SCIP_BRANCHRULEDATA}, + ), + scip, + branchruleptr, + name, + desc, + priority, + maxdepth, + maxbounddist, + branchruledata, + ) end function SCIPsetBranchruleCopy(scip, branchrule, branchcopy) - ccall((:SCIPsetBranchruleCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchcopy) + ccall( + (:SCIPsetBranchruleCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchcopy, + ) end function SCIPsetBranchruleFree(scip, branchrule, branchfree) - ccall((:SCIPsetBranchruleFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchfree) + ccall( + (:SCIPsetBranchruleFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchfree, + ) end function SCIPsetBranchruleInit(scip, branchrule, branchinit) - ccall((:SCIPsetBranchruleInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinit) + ccall( + (:SCIPsetBranchruleInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchinit, + ) end function SCIPsetBranchruleExit(scip, branchrule, branchexit) - ccall((:SCIPsetBranchruleExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexit) + ccall( + (:SCIPsetBranchruleExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchexit, + ) end function SCIPsetBranchruleInitsol(scip, branchrule, branchinitsol) - ccall((:SCIPsetBranchruleInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchinitsol) + ccall( + (:SCIPsetBranchruleInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchinitsol, + ) end function SCIPsetBranchruleExitsol(scip, branchrule, branchexitsol) - ccall((:SCIPsetBranchruleExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexitsol) + ccall( + (:SCIPsetBranchruleExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchexitsol, + ) end function SCIPsetBranchruleExecLp(scip, branchrule, branchexeclp) - ccall((:SCIPsetBranchruleExecLp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexeclp) + ccall( + (:SCIPsetBranchruleExecLp, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchexeclp, + ) end function SCIPsetBranchruleExecExt(scip, branchrule, branchexecext) - ccall((:SCIPsetBranchruleExecExt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecext) + ccall( + (:SCIPsetBranchruleExecExt, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchexecext, + ) end function SCIPsetBranchruleExecPs(scip, branchrule, branchexecps) - ccall((:SCIPsetBranchruleExecPs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), scip, branchrule, branchexecps) + ccall( + (:SCIPsetBranchruleExecPs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Ptr{Cvoid}), + scip, + branchrule, + branchexecps, + ) end function SCIPfindBranchrule(scip, name) - ccall((:SCIPfindBranchrule, libscip), Ptr{SCIP_BRANCHRULE}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindBranchrule, libscip), + Ptr{SCIP_BRANCHRULE}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetBranchrules(scip) - ccall((:SCIPgetBranchrules, libscip), Ptr{Ptr{SCIP_BRANCHRULE}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetBranchrules, libscip), + Ptr{Ptr{SCIP_BRANCHRULE}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNBranchrules(scip) @@ -3962,19 +6984,67 @@ function SCIPgetNBranchrules(scip) end function SCIPsetBranchrulePriority(scip, branchrule, priority) - ccall((:SCIPsetBranchrulePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, priority) + ccall( + (:SCIPsetBranchrulePriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), + scip, + branchrule, + priority, + ) end function SCIPsetBranchruleMaxdepth(scip, branchrule, maxdepth) - ccall((:SCIPsetBranchruleMaxdepth, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), scip, branchrule, maxdepth) + ccall( + (:SCIPsetBranchruleMaxdepth, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cint), + scip, + branchrule, + maxdepth, + ) end function SCIPsetBranchruleMaxbounddist(scip, branchrule, maxbounddist) - ccall((:SCIPsetBranchruleMaxbounddist, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BRANCHRULE}, Cdouble), scip, branchrule, maxbounddist) -end - -function SCIPgetLPBranchCands(scip, lpcands, lpcandssol, lpcandsfrac, nlpcands, npriolpcands, nfracimplvars) - ccall((:SCIPgetLPBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, lpcands, lpcandssol, lpcandsfrac, nlpcands, npriolpcands, nfracimplvars) + ccall( + (: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) @@ -3985,8 +7055,41 @@ 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) +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) @@ -4014,7 +7117,15 @@ function SCIPgetNPrioExternBranchConts(scip) end function SCIPaddExternBranchCand(scip, var, score, solval) - ccall((:SCIPaddExternBranchCand, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, score, solval) + ccall( + (:SCIPaddExternBranchCand, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + scip, + var, + score, + solval, + ) end function SCIPclearExternBranchCands(scip) @@ -4022,11 +7133,30 @@ function SCIPclearExternBranchCands(scip) end function SCIPcontainsExternBranchCand(scip, var) - ccall((:SCIPcontainsExternBranchCand, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) -end - -function SCIPgetPseudoBranchCands(scip, pseudocands, npseudocands, npriopseudocands) - ccall((:SCIPgetPseudoBranchCands, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}), scip, pseudocands, npseudocands, npriopseudocands) + ccall( + (:SCIPcontainsExternBranchCand, libscip), + Cuint, + (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) @@ -4050,123 +7180,400 @@ function SCIPgetNPrioPseudoBranchImpls(scip) end function SCIPgetBranchScore(scip, var, downgain, upgain) - ccall((:SCIPgetBranchScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, downgain, upgain) + ccall( + (:SCIPgetBranchScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + scip, + var, + downgain, + upgain, + ) end function SCIPgetBranchScoreMultiple(scip, var, nchildren, gains) - ccall((:SCIPgetBranchScoreMultiple, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, nchildren, gains) + ccall( + (:SCIPgetBranchScoreMultiple, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), + scip, + var, + nchildren, + gains, + ) end function SCIPgetBranchingPoint(scip, var, suggestion) - ccall((:SCIPgetBranchingPoint, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, suggestion) + ccall( + (:SCIPgetBranchingPoint, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + suggestion, + ) end function SCIPcalcNodeselPriority(scip, var, branchdir, targetvalue) - ccall((:SCIPcalcNodeselPriority, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), scip, var, branchdir, targetvalue) + ccall( + (:SCIPcalcNodeselPriority, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), + scip, + var, + branchdir, + targetvalue, + ) end function SCIPcalcChildEstimate(scip, var, targetvalue) - ccall((:SCIPcalcChildEstimate, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, targetvalue) + ccall( + (:SCIPcalcChildEstimate, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + targetvalue, + ) end function SCIPcalcChildEstimateIncrease(scip, var, varsol, targetvalue) - ccall((:SCIPcalcChildEstimateIncrease, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, varsol, targetvalue) + ccall( + (:SCIPcalcChildEstimateIncrease, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + scip, + var, + varsol, + targetvalue, + ) end function SCIPcreateChild(scip, node, nodeselprio, estimate) - ccall((:SCIPcreateChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NODE}}, Cdouble, Cdouble), scip, node, nodeselprio, estimate) + ccall( + (:SCIPcreateChild, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_NODE}}, Cdouble, Cdouble), + scip, + node, + nodeselprio, + estimate, + ) end function SCIPbranchVar(scip, var, downchild, eqchild, upchild) - ccall((:SCIPbranchVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, downchild, eqchild, upchild) + ccall( + (:SCIPbranchVar, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Ptr{Ptr{SCIP_NODE}}, + Ptr{Ptr{SCIP_NODE}}, + Ptr{Ptr{SCIP_NODE}}, + ), + scip, + var, + downchild, + eqchild, + upchild, + ) end function SCIPbranchVarHole(scip, var, left, right, downchild, upchild) - ccall((:SCIPbranchVarHole, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, left, right, downchild, upchild) + ccall( + (:SCIPbranchVarHole, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Ptr{Ptr{SCIP_NODE}}, + Ptr{Ptr{SCIP_NODE}}, + ), + scip, + var, + left, + right, + downchild, + upchild, + ) end function SCIPbranchVarVal(scip, var, val, downchild, eqchild, upchild) - ccall((:SCIPbranchVarVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), scip, var, val, downchild, eqchild, upchild) -end - -function SCIPbranchVarValNary(scip, var, val, n, minwidth, widthfactor, nchildren) - ccall((:SCIPbranchVarValNary, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cint, Cdouble, Cdouble, Ptr{Cint}), scip, var, val, n, minwidth, widthfactor, nchildren) + ccall( + (: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) + ccall( + (:SCIPbranchLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RESULT}), + scip, + result, + ) end function SCIPbranchExtern(scip, result) - ccall((:SCIPbranchExtern, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) + ccall( + (:SCIPbranchExtern, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RESULT}), + scip, + result, + ) end function SCIPbranchPseudo(scip, result) - ccall((:SCIPbranchPseudo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) + ccall( + (:SCIPbranchPseudo, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RESULT}), + scip, + result, + ) end function SCIPcreateDatatree(scip, datatree, capacity) - ccall((:SCIPcreateDatatree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DATATREE}}, Cint), scip, datatree, capacity) + ccall( + (:SCIPcreateDatatree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DATATREE}}, Cint), + scip, + datatree, + capacity, + ) end function SCIPcreateDatatreeInTree(scip, datatree, newtree, name, capacity) - ccall((:SCIPcreateDatatreeInTree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Ptr{SCIP_DATATREE}}, Ptr{Cchar}, Cint), scip, datatree, newtree, name, capacity) + ccall( + (:SCIPcreateDatatreeInTree, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DATATREE}, + Ptr{Ptr{SCIP_DATATREE}}, + Ptr{Cchar}, + Cint, + ), + scip, + datatree, + newtree, + name, + capacity, + ) end function SCIPinsertDatatreeBool(scip, datatree, name, value) - ccall((:SCIPinsertDatatreeBool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cuint), scip, datatree, name, value) + ccall( + (:SCIPinsertDatatreeBool, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cuint), + scip, + datatree, + name, + value, + ) end function SCIPinsertDatatreeInt(scip, datatree, name, value) - ccall((:SCIPinsertDatatreeInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cint), scip, datatree, name, value) + ccall( + (:SCIPinsertDatatreeInt, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cint), + scip, + datatree, + name, + value, + ) end function SCIPinsertDatatreeLong(scip, datatree, name, value) - ccall((:SCIPinsertDatatreeLong, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Clonglong), scip, datatree, name, value) + ccall( + (:SCIPinsertDatatreeLong, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Clonglong), + scip, + datatree, + name, + value, + ) end function SCIPinsertDatatreeReal(scip, datatree, name, value) - ccall((:SCIPinsertDatatreeReal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cdouble), scip, datatree, name, value) + ccall( + (:SCIPinsertDatatreeReal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Cdouble), + scip, + datatree, + name, + value, + ) end function SCIPinsertDatatreeString(scip, datatree, name, value) - ccall((:SCIPinsertDatatreeString, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cchar}), scip, datatree, name, value) + ccall( + (:SCIPinsertDatatreeString, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cchar}), + scip, + datatree, + name, + value, + ) end function SCIPinsertDatatreeBoolArray(scip, datatree, name, values, nvalues) - ccall((:SCIPinsertDatatreeBoolArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cuint}, Cint), scip, datatree, name, values, nvalues) + ccall( + (:SCIPinsertDatatreeBoolArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cuint}, Cint), + scip, + datatree, + name, + values, + nvalues, + ) end function SCIPinsertDatatreeIntArray(scip, datatree, name, values, nvalues) - ccall((:SCIPinsertDatatreeIntArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cint}, Cint), scip, datatree, name, values, nvalues) + ccall( + (:SCIPinsertDatatreeIntArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cint}, Cint), + scip, + datatree, + name, + values, + nvalues, + ) end function SCIPinsertDatatreeLongArray(scip, datatree, name, values, nvalues) - ccall((:SCIPinsertDatatreeLongArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Clonglong}, Cint), scip, datatree, name, values, nvalues) + ccall( + (:SCIPinsertDatatreeLongArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Clonglong}, Cint), + scip, + datatree, + name, + values, + nvalues, + ) end function SCIPinsertDatatreeRealArray(scip, datatree, name, values, nvalues) - ccall((:SCIPinsertDatatreeRealArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cdouble}, Cint), scip, datatree, name, values, nvalues) + ccall( + (:SCIPinsertDatatreeRealArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cdouble}, Cint), + scip, + datatree, + name, + values, + nvalues, + ) end function SCIPinsertDatatreeStringArray(scip, datatree, name, values, nvalues) - ccall((:SCIPinsertDatatreeStringArray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Cint), scip, datatree, name, values, nvalues) + ccall( + (:SCIPinsertDatatreeStringArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Cint), + scip, + datatree, + name, + values, + nvalues, + ) end function SCIPinsertDatatreeTree(scip, datatree, name, value) - ccall((:SCIPinsertDatatreeTree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{SCIP_DATATREE}), scip, datatree, name, value) + ccall( + (:SCIPinsertDatatreeTree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{SCIP_DATATREE}), + scip, + datatree, + name, + value, + ) end function SCIPfreeDatatree(scip, datatree) - ccall((:SCIPfreeDatatree, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DATATREE}}), scip, datatree) + ccall( + (:SCIPfreeDatatree, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DATATREE}}), + scip, + datatree, + ) end function SCIPwriteDatatreeJson(scip, file, datatree) - ccall((:SCIPwriteDatatreeJson, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_DATATREE}), scip, file, datatree) + ccall( + (:SCIPwriteDatatreeJson, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_DATATREE}), + scip, + file, + datatree, + ) end function SCIPprintDatatreeAsTable(scip, datatree, file, sectionname, tablename) - ccall((:SCIPprintDatatreeAsTable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Libc.FILE}, Ptr{Cchar}, Ptr{Cchar}), scip, datatree, file, sectionname, tablename) + ccall( + (:SCIPprintDatatreeAsTable, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}, Ptr{Libc.FILE}, Ptr{Cchar}, Ptr{Cchar}), + scip, + datatree, + file, + sectionname, + tablename, + ) end function SCIPisCertified(scip) @@ -4174,87 +7581,425 @@ function SCIPisCertified(scip) end function SCIPshouldCertificateTrackBounds(scip) - ccall((:SCIPshouldCertificateTrackBounds, libscip), Cuint, (Ptr{SCIP},), scip) + ccall( + (:SCIPshouldCertificateTrackBounds, libscip), + Cuint, + (Ptr{SCIP},), + scip, + ) end function SCIPcertifyCons(scip, isorigfile, consname, sense, side, len, ind, val) - ccall((:SCIPcertifyCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cchar}, Cchar, Ptr{SCIP_RATIONAL}, Cint, Ptr{Cint}, Ptr{Ptr{SCIP_RATIONAL}}), scip, isorigfile, consname, sense, side, len, ind, val) -end - -function SCIPcertifyActivityVarBound(scip, linename, boundtype, newbound, ismaxactivity, constraint, variable, row, vals, lhs, rhs, vars, nvars) - ccall((:SCIPcertifyActivityVarBound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, SCIP_BOUNDTYPE, Cdouble, Cuint, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_ROWEXACT}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, linename, boundtype, newbound, ismaxactivity, constraint, variable, row, vals, lhs, rhs, vars, nvars) -end - -function SCIPcertifyActivityVarBoundExact(scip, linename, boundtype, newbound, ismaxactivity, constraint, variable, row, vals, lhs, rhs, vars, nvars) - ccall((:SCIPcertifyActivityVarBoundExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, SCIP_BOUNDTYPE, Ptr{SCIP_RATIONAL}, Cuint, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_ROWEXACT}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint), scip, linename, boundtype, newbound, ismaxactivity, constraint, variable, row, vals, lhs, rhs, vars, nvars) -end - -function SCIPcertifyActivityConflict(scip, cons, row, lhs, rhs, nvals, vals, vars, diff, userhs) - ccall((:SCIPcertifyActivityConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cint, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Cuint), scip, cons, row, lhs, rhs, nvals, vals, vars, diff, userhs) -end - -function SCIPaddCertificateAggrInfo(scip, aggrrow, aggrrows, weights, naggrrows, negslackrows, negslackweights, nnegslackrows) - ccall((:SCIPaddCertificateAggrInfo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_AGGRROW}, Ptr{Ptr{SCIP_ROW}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_ROW}}, Ptr{Cdouble}, Cint), scip, aggrrow, aggrrows, weights, naggrrows, negslackrows, negslackweights, nnegslackrows) + ccall( + (:SCIPcertifyCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cuint, + Ptr{Cchar}, + Cchar, + Ptr{SCIP_RATIONAL}, + Cint, + Ptr{Cint}, + Ptr{Ptr{SCIP_RATIONAL}}, + ), + scip, + isorigfile, + consname, + sense, + side, + len, + ind, + val, + ) +end + +function SCIPcertifyActivityVarBound( + scip, + linename, + boundtype, + newbound, + ismaxactivity, + constraint, + variable, + row, + vals, + lhs, + rhs, + vars, + nvars, +) + ccall( + (:SCIPcertifyActivityVarBound, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + SCIP_BOUNDTYPE, + Cdouble, + Cuint, + Ptr{SCIP_CONS}, + Ptr{SCIP_VAR}, + Ptr{SCIP_ROWEXACT}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + ), + scip, + linename, + boundtype, + newbound, + ismaxactivity, + constraint, + variable, + row, + vals, + lhs, + rhs, + vars, + nvars, + ) +end + +function SCIPcertifyActivityVarBoundExact( + scip, + linename, + boundtype, + newbound, + ismaxactivity, + constraint, + variable, + row, + vals, + lhs, + rhs, + vars, + nvars, +) + ccall( + (:SCIPcertifyActivityVarBoundExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + SCIP_BOUNDTYPE, + Ptr{SCIP_RATIONAL}, + Cuint, + Ptr{SCIP_CONS}, + Ptr{SCIP_VAR}, + Ptr{SCIP_ROWEXACT}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + ), + scip, + linename, + boundtype, + newbound, + ismaxactivity, + constraint, + variable, + row, + vals, + lhs, + rhs, + vars, + nvars, + ) +end + +function SCIPcertifyActivityConflict( + scip, + cons, + row, + lhs, + rhs, + nvals, + vals, + vars, + diff, + userhs, +) + ccall( + (:SCIPcertifyActivityConflict, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_CONS}, + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Cint, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{SCIP_RATIONAL}, + Cuint, + ), + scip, + cons, + row, + lhs, + rhs, + nvals, + vals, + vars, + diff, + userhs, + ) +end + +function SCIPaddCertificateAggrInfo( + scip, + aggrrow, + aggrrows, + weights, + naggrrows, + negslackrows, + negslackweights, + nnegslackrows, +) + ccall( + (:SCIPaddCertificateAggrInfo, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_AGGRROW}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{Cdouble}, + Cint, + Ptr{Ptr{SCIP_ROW}}, + Ptr{Cdouble}, + Cint, + ), + scip, + aggrrow, + aggrrows, + weights, + naggrrows, + negslackrows, + negslackweights, + nnegslackrows, + ) end function SCIPstoreCertificateActiveAggrInfo(scip, row) - ccall((:SCIPstoreCertificateActiveAggrInfo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPstoreCertificateActiveAggrInfo, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPfreeCertificateActiveAggrInfo(scip) - ccall((:SCIPfreeCertificateActiveAggrInfo, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPfreeCertificateActiveAggrInfo, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPaddCertificateMirInfo(scip) - ccall((:SCIPaddCertificateMirInfo, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPaddCertificateMirInfo, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPstoreCertificateActiveMirInfo(scip, row) - ccall((:SCIPstoreCertificateActiveMirInfo, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPstoreCertificateActiveMirInfo, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPcertifyMirCut(scip, row) - ccall((:SCIPcertifyMirCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPcertifyMirCut, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPfreeCertificateActiveMirInfo(scip) - ccall((:SCIPfreeCertificateActiveMirInfo, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPincludeCompr(scip, name, desc, priority, minnnodes, comprcopy, comprfree, comprinit, comprexit, comprinitsol, comprexitsol, comprexec, comprdata) - ccall((:SCIPincludeCompr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_COMPRDATA}), scip, compr, name, desc, priority, minnnodes, comprexec, comprdata) + ccall( + (:SCIPfreeCertificateActiveMirInfo, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPincludeCompr( + scip, + name, + desc, + priority, + minnnodes, + comprcopy, + comprfree, + comprinit, + comprexit, + comprinitsol, + comprexitsol, + comprexec, + comprdata, +) + ccall( + (:SCIPincludeCompr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Ptr{Cvoid}, + Ptr{SCIP_COMPRDATA}, + ), + scip, + compr, + name, + desc, + priority, + minnnodes, + comprexec, + comprdata, + ) end function SCIPsetComprCopy(scip, compr, comprcopy) - ccall((:SCIPsetComprCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprcopy) + ccall( + (:SCIPsetComprCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), + scip, + compr, + comprcopy, + ) end function SCIPsetComprFree(scip, compr, comprfree) - ccall((:SCIPsetComprFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprfree) + ccall( + (:SCIPsetComprFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), + scip, + compr, + comprfree, + ) end function SCIPsetComprInit(scip, compr, comprinit) - ccall((:SCIPsetComprInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinit) + ccall( + (:SCIPsetComprInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), + scip, + compr, + comprinit, + ) end function SCIPsetComprExit(scip, compr, comprexit) - ccall((:SCIPsetComprExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexit) + ccall( + (:SCIPsetComprExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), + scip, + compr, + comprexit, + ) end function SCIPsetComprInitsol(scip, compr, comprinitsol) - ccall((:SCIPsetComprInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprinitsol) + ccall( + (:SCIPsetComprInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), + scip, + compr, + comprinitsol, + ) end function SCIPsetComprExitsol(scip, compr, comprexitsol) - ccall((:SCIPsetComprExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), scip, compr, comprexitsol) + ccall( + (:SCIPsetComprExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_COMPR}, Ptr{Cvoid}), + scip, + compr, + comprexitsol, + ) end function SCIPfindCompr(scip, name) - ccall((:SCIPfindCompr, libscip), Ptr{SCIP_COMPR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindCompr, libscip), + Ptr{SCIP_COMPR}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetComprs(scip) @@ -4266,19 +8011,82 @@ function SCIPgetNCompr(scip) end function SCIPsetComprPriority(scip, compr, priority) - ccall((:SCIPsetComprPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_COMPR}, Cint), scip, compr, priority) -end - -function SCIPincludeConcsolverType(scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) - ccall((:SCIPincludeConcsolverType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CONCSOLVERTYPEDATA}), scip, name, prefpriodefault, concsolvercreateinst, concsolverdestroyinst, concsolverinitseeds, concsolverexec, concsolvercopysolvdata, concsolverstop, concsolversyncwrite, concsolversyncread, concsolvertypefreedata, data) + ccall( + (:SCIPsetComprPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_COMPR}, Cint), + scip, + compr, + priority, + ) +end + +function SCIPincludeConcsolverType( + scip, + name, + prefpriodefault, + concsolvercreateinst, + concsolverdestroyinst, + concsolverinitseeds, + concsolverexec, + concsolvercopysolvdata, + concsolverstop, + concsolversyncwrite, + concsolversyncread, + concsolvertypefreedata, + data, +) + ccall( + (:SCIPincludeConcsolverType, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + 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}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindConcsolverType, libscip), + Ptr{SCIP_CONCSOLVERTYPE}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetConcsolverTypes(scip) - ccall((:SCIPgetConcsolverTypes, libscip), Ptr{Ptr{SCIP_CONCSOLVERTYPE}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetConcsolverTypes, libscip), + Ptr{Ptr{SCIP_CONCSOLVERTYPE}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNConcsolverTypes(scip) @@ -4297,44 +8105,166 @@ function SCIPgetSyncstore(scip) ccall((:SCIPgetSyncstore, libscip), Ptr{SCIP_SYNCSTORE}, (Ptr{SCIP},), scip) end -function SCIPincludeConflicthdlr(scip, name, desc, priority, conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec, conflicthdlrdata) - ccall((:SCIPincludeConflicthdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{SCIP_CONFLICTHDLRDATA}), scip, conflicthdlrptr, name, desc, priority, conflictexec, conflicthdlrdata) +function SCIPincludeConflicthdlr( + scip, + name, + desc, + priority, + conflictcopy, + conflictfree, + conflictinit, + conflictexit, + conflictinitsol, + conflictexitsol, + conflictexec, + conflicthdlrdata, +) + ccall( + (:SCIPincludeConflicthdlr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Ptr{Cvoid}, + Ptr{SCIP_CONFLICTHDLRDATA}, + ), + scip, + conflicthdlrptr, + name, + desc, + priority, + conflictexec, + conflicthdlrdata, + ) end function SCIPsetConflicthdlrCopy(scip, conflicthdlr, conflictcopy) - ccall((:SCIPsetConflicthdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictcopy) + ccall( + (:SCIPsetConflicthdlrCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), + scip, + conflicthdlr, + conflictcopy, + ) end function SCIPsetConflicthdlrFree(scip, conflicthdlr, conflictfree) - ccall((:SCIPsetConflicthdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictfree) + ccall( + (:SCIPsetConflicthdlrFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), + scip, + conflicthdlr, + conflictfree, + ) end function SCIPsetConflicthdlrInit(scip, conflicthdlr, conflictinit) - ccall((:SCIPsetConflicthdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinit) + ccall( + (:SCIPsetConflicthdlrInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), + scip, + conflicthdlr, + conflictinit, + ) end function SCIPsetConflicthdlrExit(scip, conflicthdlr, conflictexit) - ccall((:SCIPsetConflicthdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexit) + ccall( + (:SCIPsetConflicthdlrExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), + scip, + conflicthdlr, + conflictexit, + ) end function SCIPsetConflicthdlrInitsol(scip, conflicthdlr, conflictinitsol) - ccall((:SCIPsetConflicthdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictinitsol) + ccall( + (:SCIPsetConflicthdlrInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), + scip, + conflicthdlr, + conflictinitsol, + ) end function SCIPsetConflicthdlrExitsol(scip, conflicthdlr, conflictexitsol) - ccall((:SCIPsetConflicthdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), scip, conflicthdlr, conflictexitsol) + ccall( + (:SCIPsetConflicthdlrExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Ptr{Cvoid}), + scip, + conflicthdlr, + conflictexitsol, + ) end function SCIPfindConflicthdlr(scip, name) - ccall((:SCIPfindConflicthdlr, libscip), Ptr{SCIP_CONFLICTHDLR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindConflicthdlr, libscip), + Ptr{SCIP_CONFLICTHDLR}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetConflicthdlrs(scip) - ccall((:SCIPgetConflicthdlrs, libscip), Ptr{Ptr{SCIP_CONFLICTHDLR}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetConflicthdlrs, libscip), + Ptr{Ptr{SCIP_CONFLICTHDLR}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNConflicthdlrs(scip) @@ -4342,479 +8272,2082 @@ function SCIPgetNConflicthdlrs(scip) end function SCIPsetConflicthdlrPriority(scip, conflicthdlr, priority) - ccall((:SCIPsetConflicthdlrPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Cint), scip, conflicthdlr, priority) + ccall( + (:SCIPsetConflicthdlrPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONFLICTHDLR}, Cint), + scip, + conflicthdlr, + priority, + ) end function SCIPisConflictAnalysisApplicable(scip) - ccall((:SCIPisConflictAnalysisApplicable, libscip), Cuint, (Ptr{SCIP},), scip) + ccall( + (:SCIPisConflictAnalysisApplicable, libscip), + Cuint, + (Ptr{SCIP},), + scip, + ) end function SCIPinitConflictAnalysis(scip, conftype, iscutoffinvolved) - ccall((:SCIPinitConflictAnalysis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_CONFTYPE, Cuint), scip, conftype, iscutoffinvolved) + ccall( + (:SCIPinitConflictAnalysis, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, SCIP_CONFTYPE, Cuint), + scip, + conftype, + iscutoffinvolved, + ) end function SCIPaddConflictLb(scip, var, bdchgidx) - ccall((:SCIPaddConflictLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) + ccall( + (:SCIPaddConflictLb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), + scip, + var, + bdchgidx, + ) end function SCIPaddConflictRelaxedLb(scip, var, bdchgidx, relaxedlb) - ccall((:SCIPaddConflictRelaxedLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedlb) + ccall( + (:SCIPaddConflictRelaxedLb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), + scip, + var, + bdchgidx, + relaxedlb, + ) end function SCIPaddConflictUb(scip, var, bdchgidx) - ccall((:SCIPaddConflictUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), scip, var, bdchgidx) + ccall( + (:SCIPaddConflictUb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}), + scip, + var, + bdchgidx, + ) end function SCIPaddConflictRelaxedUb(scip, var, bdchgidx, relaxedub) - ccall((:SCIPaddConflictRelaxedUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, bdchgidx, relaxedub) + ccall( + (:SCIPaddConflictRelaxedUb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cdouble), + scip, + var, + bdchgidx, + relaxedub, + ) end function SCIPaddConflictBd(scip, var, boundtype, bdchgidx) - ccall((:SCIPaddConflictBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}), scip, var, boundtype, bdchgidx) + ccall( + (:SCIPaddConflictBd, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}), + scip, + var, + boundtype, + bdchgidx, + ) end function SCIPaddConflictRelaxedBd(scip, var, boundtype, bdchgidx, relaxedbd) - ccall((:SCIPaddConflictRelaxedBd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble), scip, var, boundtype, bdchgidx, relaxedbd) + ccall( + (:SCIPaddConflictRelaxedBd, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cdouble), + scip, + var, + boundtype, + bdchgidx, + relaxedbd, + ) end function SCIPaddConflictBinvar(scip, var) - ccall((:SCIPaddConflictBinvar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPaddConflictBinvar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPisConflictVarUsed(scip, var, boundtype, bdchgidx, used) - ccall((:SCIPisConflictVarUsed, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Ptr{Cuint}), scip, var, boundtype, bdchgidx, used) + ccall( + (:SCIPisConflictVarUsed, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + SCIP_BOUNDTYPE, + Ptr{SCIP_BDCHGIDX}, + Ptr{Cuint}, + ), + scip, + var, + boundtype, + bdchgidx, + used, + ) end function SCIPgetConflictVarLb(scip, var) - ccall((:SCIPgetConflictVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetConflictVarLb, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetConflictVarUb(scip, var) - ccall((:SCIPgetConflictVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetConflictVarUb, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPanalyzeConflict(scip, validdepth, success) - ccall((:SCIPanalyzeConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}), scip, validdepth, success) + ccall( + (:SCIPanalyzeConflict, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cuint}), + scip, + validdepth, + success, + ) end function SCIPanalyzeConflictCons(scip, cons, success) - ccall((:SCIPanalyzeConflictCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) -end - -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, consgetpermsymgraph, consgetsignedpermsymgraph, conshdlrdata) - ccall((:SCIPincludeConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cint, Cint, Cint, Cint, Cint, Cuint, Cuint, Cuint, 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{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, consgetpermsymgraph, consgetsignedpermsymgraph, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cint, Cuint, 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, Cuint), 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, Cuint, SCIP_PROPTIMING), scip, conshdlr, consprop, propfreq, delayprop, proptiming) + ccall( + (:SCIPanalyzeConflictCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), + scip, + cons, + success, + ) +end + +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, + consgetpermsymgraph, + consgetsignedpermsymgraph, + conshdlrdata, +) + ccall( + (:SCIPincludeConshdlr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Cint, + Cint, + Cint, + Cint, + Cint, + Cuint, + Cuint, + Cuint, + 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{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, + consgetpermsymgraph, + consgetsignedpermsymgraph, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Cint, + Cuint, + 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, + Cuint, + ), + 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, + Cuint, + SCIP_PROPTIMING, + ), + scip, + conshdlr, + consprop, + propfreq, + delayprop, + proptiming, + ) end function SCIPsetConshdlrEnforelax(scip, conshdlr, consenforelax) - ccall((:SCIPsetConshdlrEnforelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenforelax) + ccall( + (:SCIPsetConshdlrEnforelax, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consenforelax, + ) end function SCIPsetConshdlrCopy(scip, conshdlr, conshdlrcopy, conscopy) - ccall((:SCIPsetConshdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, conshdlr, conshdlrcopy, conscopy) + ccall( + (:SCIPsetConshdlrCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), + scip, + conshdlr, + conshdlrcopy, + conscopy, + ) end function SCIPsetConshdlrFree(scip, conshdlr, consfree) - ccall((:SCIPsetConshdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consfree) + ccall( + (:SCIPsetConshdlrFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consfree, + ) end function SCIPsetConshdlrInit(scip, conshdlr, consinit) - ccall((:SCIPsetConshdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinit) + ccall( + (:SCIPsetConshdlrInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consinit, + ) end function SCIPsetConshdlrExit(scip, conshdlr, consexit) - ccall((:SCIPsetConshdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexit) + ccall( + (:SCIPsetConshdlrExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consexit, + ) end function SCIPsetConshdlrInitsol(scip, conshdlr, consinitsol) - ccall((:SCIPsetConshdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitsol) + ccall( + (:SCIPsetConshdlrInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consinitsol, + ) end function SCIPsetConshdlrExitsol(scip, conshdlr, consexitsol) - ccall((:SCIPsetConshdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitsol) + ccall( + (:SCIPsetConshdlrExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consexitsol, + ) end function SCIPsetConshdlrInitpre(scip, conshdlr, consinitpre) - ccall((:SCIPsetConshdlrInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitpre) + ccall( + (:SCIPsetConshdlrInitpre, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consinitpre, + ) end function SCIPsetConshdlrExitpre(scip, conshdlr, consexitpre) - ccall((:SCIPsetConshdlrExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consexitpre) -end - -function SCIPsetConshdlrPresol(scip, conshdlr, conspresol, maxprerounds, presoltiming) - ccall((:SCIPsetConshdlrPresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, SCIP_PRESOLTIMING), scip, conshdlr, conspresol, maxprerounds, presoltiming) + ccall( + (: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) + ccall( + (:SCIPsetConshdlrDelete, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consdelete, + ) end function SCIPsetConshdlrTrans(scip, conshdlr, constrans) - ccall((:SCIPsetConshdlrTrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, constrans) + ccall( + (:SCIPsetConshdlrTrans, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + constrans, + ) end function SCIPsetConshdlrInitlp(scip, conshdlr, consinitlp) - ccall((:SCIPsetConshdlrInitlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consinitlp) + ccall( + (:SCIPsetConshdlrInitlp, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consinitlp, + ) end function SCIPsetConshdlrResprop(scip, conshdlr, consresprop) - ccall((:SCIPsetConshdlrResprop, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consresprop) + ccall( + (:SCIPsetConshdlrResprop, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consresprop, + ) end function SCIPsetConshdlrActive(scip, conshdlr, consactive) - ccall((:SCIPsetConshdlrActive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consactive) + ccall( + (:SCIPsetConshdlrActive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consactive, + ) end function SCIPsetConshdlrDeactive(scip, conshdlr, consdeactive) - ccall((:SCIPsetConshdlrDeactive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdeactive) + ccall( + (:SCIPsetConshdlrDeactive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consdeactive, + ) end function SCIPsetConshdlrEnable(scip, conshdlr, consenable) - ccall((:SCIPsetConshdlrEnable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consenable) + ccall( + (:SCIPsetConshdlrEnable, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consenable, + ) end function SCIPsetConshdlrDisable(scip, conshdlr, consdisable) - ccall((:SCIPsetConshdlrDisable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdisable) + ccall( + (:SCIPsetConshdlrDisable, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consdisable, + ) end function SCIPsetConshdlrDelvars(scip, conshdlr, consdelvars) - ccall((:SCIPsetConshdlrDelvars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consdelvars) + ccall( + (:SCIPsetConshdlrDelvars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consdelvars, + ) end function SCIPsetConshdlrPrint(scip, conshdlr, consprint) - ccall((:SCIPsetConshdlrPrint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consprint) + ccall( + (:SCIPsetConshdlrPrint, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consprint, + ) end function SCIPsetConshdlrParse(scip, conshdlr, consparse) - ccall((:SCIPsetConshdlrParse, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consparse) + ccall( + (:SCIPsetConshdlrParse, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consparse, + ) end function SCIPsetConshdlrGetVars(scip, conshdlr, consgetvars) - ccall((:SCIPsetConshdlrGetVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetvars) + ccall( + (:SCIPsetConshdlrGetVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consgetvars, + ) end function SCIPsetConshdlrGetNVars(scip, conshdlr, consgetnvars) - ccall((:SCIPsetConshdlrGetNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetnvars) + ccall( + (:SCIPsetConshdlrGetNVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consgetnvars, + ) end function SCIPsetConshdlrGetDiveBdChgs(scip, conshdlr, consgetdivebdchgs) - ccall((:SCIPsetConshdlrGetDiveBdChgs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetdivebdchgs) + ccall( + (:SCIPsetConshdlrGetDiveBdChgs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consgetdivebdchgs, + ) end function SCIPsetConshdlrGetPermsymGraph(scip, conshdlr, consgetpermsymgraph) - ccall((:SCIPsetConshdlrGetPermsymGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetpermsymgraph) -end - -function SCIPsetConshdlrGetSignedPermsymGraph(scip, conshdlr, consgetsignedpermsymgraph) - ccall((:SCIPsetConshdlrGetSignedPermsymGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), scip, conshdlr, consgetsignedpermsymgraph) + ccall( + (:SCIPsetConshdlrGetPermsymGraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consgetpermsymgraph, + ) +end + +function SCIPsetConshdlrGetSignedPermsymGraph( + scip, + conshdlr, + consgetsignedpermsymgraph, +) + ccall( + (:SCIPsetConshdlrGetSignedPermsymGraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), + scip, + conshdlr, + consgetsignedpermsymgraph, + ) end function SCIPfindConshdlr(scip, name) - ccall((:SCIPfindConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindConshdlr, libscip), + Ptr{SCIP_CONSHDLR}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetConshdlrs(scip) - ccall((:SCIPgetConshdlrs, libscip), Ptr{Ptr{SCIP_CONSHDLR}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetConshdlrs, libscip), + Ptr{Ptr{SCIP_CONSHDLR}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNConshdlrs(scip) ccall((:SCIPgetNConshdlrs, libscip), Cint, (Ptr{SCIP},), scip) 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}}, Ptr{Cchar}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONSDATA}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), scip, cons, str, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, success) +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}}, + Ptr{Cchar}, + Ptr{SCIP_CONSHDLR}, + Ptr{SCIP_CONSDATA}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + scip, + cons, + str, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + success, + ) end function SCIPcaptureCons(scip, cons) - ccall((:SCIPcaptureCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPcaptureCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPreleaseCons(scip, cons) - ccall((:SCIPreleaseCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}), scip, cons) + ccall( + (:SCIPreleaseCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}), + scip, + cons, + ) end function SCIPchgConsName(scip, cons, name) - ccall((:SCIPchgConsName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cchar}), scip, cons, name) + ccall( + (:SCIPchgConsName, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cchar}), + scip, + cons, + name, + ) end function SCIPsetConsInitial(scip, cons, initial) - ccall((:SCIPsetConsInitial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, initial) + ccall( + (:SCIPsetConsInitial, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + initial, + ) end function SCIPsetConsSeparated(scip, cons, separate) - ccall((:SCIPsetConsSeparated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, separate) + ccall( + (:SCIPsetConsSeparated, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + separate, + ) end function SCIPsetConsEnforced(scip, cons, enforce) - ccall((:SCIPsetConsEnforced, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, enforce) + ccall( + (:SCIPsetConsEnforced, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + enforce, + ) end function SCIPsetConsChecked(scip, cons, check) - ccall((:SCIPsetConsChecked, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, check) + ccall( + (:SCIPsetConsChecked, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + check, + ) end function SCIPsetConsPropagated(scip, cons, propagate) - ccall((:SCIPsetConsPropagated, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, propagate) + ccall( + (:SCIPsetConsPropagated, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + propagate, + ) end function SCIPsetConsLocal(scip, cons, _local) - ccall((:SCIPsetConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, _local) + ccall( + (:SCIPsetConsLocal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + _local, + ) end function SCIPsetConsModifiable(scip, cons, modifiable) - ccall((:SCIPsetConsModifiable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, modifiable) + ccall( + (:SCIPsetConsModifiable, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + modifiable, + ) end function SCIPsetConsDynamic(scip, cons, dynamic) - ccall((:SCIPsetConsDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, dynamic) + ccall( + (:SCIPsetConsDynamic, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + dynamic, + ) end function SCIPsetConsRemovable(scip, cons, removable) - ccall((:SCIPsetConsRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, removable) + ccall( + (:SCIPsetConsRemovable, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + removable, + ) end function SCIPsetConsStickingAtNode(scip, cons, stickingatnode) - ccall((:SCIPsetConsStickingAtNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), scip, cons, stickingatnode) + ccall( + (:SCIPsetConsStickingAtNode, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint), + scip, + cons, + stickingatnode, + ) end function SCIPupdateConsFlags(scip, cons0, cons1) - ccall((:SCIPupdateConsFlags, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), scip, cons0, cons1) + ccall( + (:SCIPupdateConsFlags, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), + scip, + cons0, + cons1, + ) end function SCIPtransformCons(scip, cons, transcons) - ccall((:SCIPtransformCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) + ccall( + (:SCIPtransformCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), + scip, + cons, + transcons, + ) end function SCIPtransformConss(scip, nconss, conss, transconss) - ccall((:SCIPtransformConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) + ccall( + (:SCIPtransformConss, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), + scip, + nconss, + conss, + transconss, + ) end function SCIPgetTransformedCons(scip, cons, transcons) - ccall((:SCIPgetTransformedCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, cons, transcons) + ccall( + (:SCIPgetTransformedCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), + scip, + cons, + transcons, + ) end function SCIPgetTransformedConss(scip, nconss, conss, transconss) - ccall((:SCIPgetTransformedConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), scip, nconss, conss, transconss) + ccall( + (:SCIPgetTransformedConss, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Ptr{SCIP_CONS}}), + scip, + nconss, + conss, + transconss, + ) end function SCIPaddConsAge(scip, cons, deltaage) - ccall((:SCIPaddConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, deltaage) + ccall( + (:SCIPaddConsAge, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), + scip, + cons, + deltaage, + ) end function SCIPincConsAge(scip, cons) - ccall((:SCIPincConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPincConsAge, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPresetConsAge(scip, cons) - ccall((:SCIPresetConsAge, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPresetConsAge, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPenableCons(scip, cons) - ccall((:SCIPenableCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPenableCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPdisableCons(scip, cons) - ccall((:SCIPdisableCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPdisableCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPenableConsSeparation(scip, cons) - ccall((:SCIPenableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPenableConsSeparation, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPdisableConsSeparation(scip, cons) - ccall((:SCIPdisableConsSeparation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPdisableConsSeparation, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPenableConsPropagation(scip, cons) - ccall((:SCIPenableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPenableConsPropagation, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPdisableConsPropagation(scip, cons) - ccall((:SCIPdisableConsPropagation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPdisableConsPropagation, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPmarkConsPropagate(scip, cons) - ccall((:SCIPmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPmarkConsPropagate, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPunmarkConsPropagate(scip, cons) - ccall((:SCIPunmarkConsPropagate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPunmarkConsPropagate, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPaddConsLocksType(scip, cons, locktype, nlockspos, nlocksneg) - ccall((:SCIPaddConsLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_LOCKTYPE, Cint, Cint), scip, cons, locktype, nlockspos, nlocksneg) + ccall( + (:SCIPaddConsLocksType, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_LOCKTYPE, Cint, Cint), + scip, + cons, + locktype, + nlockspos, + nlocksneg, + ) end function SCIPaddConsLocks(scip, cons, nlockspos, nlocksneg) - ccall((:SCIPaddConsLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cint, Cint), scip, cons, nlockspos, nlocksneg) -end - -function SCIPcheckCons(scip, cons, sol, checkintegrality, checklprows, printreason, result) - ccall((:SCIPcheckCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Cuint, Cuint, Cuint, Ptr{SCIP_RESULT}), scip, cons, sol, checkintegrality, checklprows, printreason, result) + 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}, + Cuint, + Cuint, + Cuint, + 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}, Cuint, Cuint, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, objinfeasible, result) + ccall( + (:SCIPenfopsCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint, Cuint, 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}, Cuint, Ptr{SCIP_RESULT}), scip, cons, solinfeasible, result) + ccall( + (:SCIPenfolpCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint, 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}, Cuint, Ptr{SCIP_RESULT}), scip, cons, sol, solinfeasible, result) + ccall( + (:SCIPenforelaxCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Cuint, 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{Cuint}), scip, cons, infeasible) + ccall( + (:SCIPinitlpCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), + scip, + cons, + infeasible, + ) end function SCIPsepalpCons(scip, cons, result) - ccall((:SCIPsepalpCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RESULT}), scip, cons, result) + ccall( + (:SCIPsepalpCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RESULT}), + scip, + cons, + result, + ) end function SCIPsepasolCons(scip, cons, sol, result) - ccall((:SCIPsepasolCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, cons, sol, result) + ccall( + (:SCIPsepasolCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), + scip, + cons, + sol, + result, + ) end function SCIPpropCons(scip, cons, proptiming, result) - ccall((:SCIPpropCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, SCIP_PROPTIMING, Ptr{SCIP_RESULT}), scip, cons, proptiming, result) -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) + 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) + ccall( + (:SCIPactiveCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPdeactiveCons(scip, cons) - ccall((:SCIPdeactiveCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPdeactiveCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPprintCons(scip, cons, file) - ccall((:SCIPprintCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Libc.FILE}), scip, cons, file) + ccall( + (:SCIPprintCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Libc.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{Cuint}), scip, cons, vars, varssize, success) + ccall( + (:SCIPgetConsVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cuint}), + 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{Cuint}), scip, cons, nvars, success) + ccall( + (:SCIPgetConsNVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cint}, Ptr{Cuint}), + scip, + cons, + nvars, + success, + ) end function SCIPgetConsPermsymGraph(scip, cons, graph, success) - ccall((:SCIPgetConsPermsymGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SYM_GRAPH}, Ptr{Cuint}), scip, cons, graph, success) + ccall( + (:SCIPgetConsPermsymGraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SYM_GRAPH}, Ptr{Cuint}), + scip, + cons, + graph, + success, + ) end function SCIPgetConsSignedPermsymGraph(scip, cons, graph, success) - ccall((:SCIPgetConsSignedPermsymGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SYM_GRAPH}, Ptr{Cuint}), scip, cons, graph, success) -end - -function SCIPcopyPlugins(sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copyiisfinders, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, passmessagehdlr, valid) - ccall((:SCIPcopyPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copyiisfinders, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, passmessagehdlr, valid) + ccall( + (:SCIPgetConsSignedPermsymGraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SYM_GRAPH}, Ptr{Cuint}), + scip, + cons, + graph, + success, + ) +end + +function SCIPcopyPlugins( + sourcescip, + targetscip, + copyreaders, + copypricers, + copyconshdlrs, + copyconflicthdlrs, + copypresolvers, + copyrelaxators, + copyseparators, + copycutselectors, + copypropagators, + copyheuristics, + copyeventhdlrs, + copynodeselectors, + copybranchrules, + copyiisfinders, + copydisplays, + copydialogs, + copytables, + copyexprhdlrs, + copynlpis, + passmessagehdlr, + valid, +) + ccall( + (:SCIPcopyPlugins, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + sourcescip, + targetscip, + copyreaders, + copypricers, + copyconshdlrs, + copyconflicthdlrs, + copypresolvers, + copyrelaxators, + copyseparators, + copycutselectors, + copypropagators, + copyheuristics, + copyeventhdlrs, + copynodeselectors, + copybranchrules, + copyiisfinders, + copydisplays, + copydialogs, + copytables, + copyexprhdlrs, + copynlpis, + passmessagehdlr, + valid, + ) end function SCIPcopyBenders(sourcescip, targetscip, varmap, threadsafe, valid) - ccall((:SCIPcopyBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, threadsafe, valid) + ccall( + (:SCIPcopyBenders, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Cuint, Ptr{Cuint}), + sourcescip, + targetscip, + varmap, + threadsafe, + 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}, Cuint, Ptr{Cchar}), sourcescip, targetscip, varmap, consmap, _global, name) + ccall( + (:SCIPcopyProb, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Cuint, + Ptr{Cchar}, + ), + 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}, Ptr{Cchar}), sourcescip, targetscip, varmap, consmap, name) + ccall( + (:SCIPcopyOrigProb, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Ptr{Cchar}, + ), + sourcescip, + targetscip, + varmap, + consmap, + name, + ) end function SCIPenableConsCompression(scip) - ccall((:SCIPenableConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPenableConsCompression, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPisConsCompressionEnabled(scip) ccall((:SCIPisConsCompressionEnabled, libscip), Cuint, (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}, Cuint, Ptr{Cuint}), 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, Cuint), 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) +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}, + Cuint, + Ptr{Cuint}, + ), + 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, + Cuint, + ), + 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 SCIPmergeNLPIStatistics(sourcescip, targetscip, reset) - ccall((:SCIPmergeNLPIStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP}, Cuint), sourcescip, targetscip, reset) + ccall( + (:SCIPmergeNLPIStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP}, Cuint), + sourcescip, + targetscip, + reset, + ) end function SCIPtranslateSubSol(scip, subscip, subsol, heur, subvars, newsol) - ccall((:SCIPtranslateSubSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_SOL}}), scip, subscip, subsol, heur, subvars, newsol) + ccall( + (:SCIPtranslateSubSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_SOL}, + Ptr{SCIP_HEUR}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_SOL}}, + ), + scip, + subscip, + subsol, + heur, + subvars, + newsol, + ) end function SCIPtranslateSubSols(scip, subscip, heur, subvars, success, solindex) - ccall((:SCIPtranslateSubSols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}, Ptr{Cint}), scip, subscip, heur, subvars, success, solindex) -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}, Ptr{Cchar}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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}, Cuint, Cuint, Ptr{Cuint}), 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}, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, enablepricing, valid) + ccall( + (:SCIPtranslateSubSols, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_HEUR}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cuint}, + Ptr{Cint}, + ), + scip, + subscip, + heur, + subvars, + success, + solindex, + ) +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}, + Ptr{Cchar}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + 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}, + Cuint, + Cuint, + Ptr{Cuint}, + ), + 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}, + Cuint, + Ptr{Cuint}, + ), + 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}, Cuint, 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}, Cuint, 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}, Cuint, Cuint, Ptr{Cuint}), 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}, Cuint, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}), sourcescip, targetscip, varmap, consmap, _global, infeasible, nbdchgs, ncopied) + ccall( + (:SCIPconvertCutsToConss, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cuint, 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}, + Cuint, + 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}, + Cuint, + Cuint, + Ptr{Cuint}, + ), + 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}, + Cuint, + Ptr{Cuint}, + Ptr{Cint}, + Ptr{Cint}, + ), + sourcescip, + targetscip, + varmap, + consmap, + _global, + infeasible, + nbdchgs, + ncopied, + ) end function SCIPcopyParamSettings(sourcescip, targetscip) - ccall((:SCIPcopyParamSettings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}), sourcescip, targetscip) + ccall( + (:SCIPcopyParamSettings, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP}), + sourcescip, + targetscip, + ) end function SCIPgetSubscipDepth(scip) @@ -4822,75 +10355,330 @@ function SCIPgetSubscipDepth(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, threadsafe, passmessagehdlr, valid) - ccall((:SCIPcopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, suffix, _global, enablepricing, threadsafe, passmessagehdlr, valid) -end - -function SCIPcopyConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, threadsafe, passmessagehdlr, valid) - ccall((:SCIPcopyConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, _global, enablepricing, threadsafe, passmessagehdlr, valid) -end - -function SCIPcopyOrig(sourcescip, targetscip, varmap, consmap, suffix, enablepricing, threadsafe, passmessagehdlr, valid) - ccall((:SCIPcopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, suffix, enablepricing, threadsafe, passmessagehdlr, valid) -end - -function SCIPcopyOrigConsCompression(sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, threadsafe, passmessagehdlr, valid) - ccall((:SCIPcopyOrigConsCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourcescip, targetscip, varmap, consmap, suffix, fixedvars, fixedvals, nfixedvars, enablepricing, threadsafe, passmessagehdlr, valid) + ccall( + (:SCIPsetSubscipDepth, libscip), + Cvoid, + (Ptr{SCIP}, Cint), + scip, + newdepth, + ) +end + +function SCIPcopy( + sourcescip, + targetscip, + varmap, + consmap, + suffix, + _global, + enablepricing, + threadsafe, + passmessagehdlr, + valid, +) + ccall( + (:SCIPcopy, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Ptr{Cchar}, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + sourcescip, + targetscip, + varmap, + consmap, + suffix, + _global, + enablepricing, + threadsafe, + passmessagehdlr, + valid, + ) +end + +function SCIPcopyConsCompression( + sourcescip, + targetscip, + varmap, + consmap, + suffix, + fixedvars, + fixedvals, + nfixedvars, + _global, + enablepricing, + threadsafe, + passmessagehdlr, + valid, +) + ccall( + (:SCIPcopyConsCompression, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + sourcescip, + targetscip, + varmap, + consmap, + suffix, + fixedvars, + fixedvals, + nfixedvars, + _global, + enablepricing, + threadsafe, + passmessagehdlr, + valid, + ) +end + +function SCIPcopyOrig( + sourcescip, + targetscip, + varmap, + consmap, + suffix, + enablepricing, + threadsafe, + passmessagehdlr, + valid, +) + ccall( + (:SCIPcopyOrig, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Ptr{Cchar}, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + sourcescip, + targetscip, + varmap, + consmap, + suffix, + enablepricing, + threadsafe, + passmessagehdlr, + valid, + ) +end + +function SCIPcopyOrigConsCompression( + sourcescip, + targetscip, + varmap, + consmap, + suffix, + fixedvars, + fixedvals, + nfixedvars, + enablepricing, + threadsafe, + passmessagehdlr, + valid, +) + ccall( + (:SCIPcopyOrigConsCompression, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + sourcescip, + targetscip, + varmap, + consmap, + suffix, + fixedvars, + fixedvals, + nfixedvars, + enablepricing, + threadsafe, + passmessagehdlr, + valid, + ) end function SCIPcheckCopyLimits(sourcescip, success) - ccall((:SCIPcheckCopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), sourcescip, success) + ccall( + (:SCIPcheckCopyLimits, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}), + sourcescip, + success, + ) end function SCIPcopyLimits(sourcescip, targetscip) - ccall((:SCIPcopyLimits, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}), sourcescip, targetscip) -end - -function SCIPsetCommonSubscipParams(sourcescip, subscip, nsubnodes, nstallnodes, bestsollimit) - ccall((:SCIPsetCommonSubscipParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Clonglong, Clonglong, Cint), sourcescip, subscip, nsubnodes, nstallnodes, bestsollimit) + ccall( + (:SCIPcopyLimits, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP}), + sourcescip, + targetscip, + ) +end + +function SCIPsetCommonSubscipParams( + sourcescip, + subscip, + nsubnodes, + nstallnodes, + bestsollimit, +) + ccall( + (:SCIPsetCommonSubscipParams, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP}, Clonglong, Clonglong, Cint), + sourcescip, + subscip, + nsubnodes, + nstallnodes, + bestsollimit, + ) end function SCIPgetCutLPSolCutoffDistance(scip, sol, cut) - ccall((:SCIPgetCutLPSolCutoffDistance, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) + ccall( + (:SCIPgetCutLPSolCutoffDistance, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), + scip, + sol, + cut, + ) end function SCIPgetCutEfficacy(scip, sol, cut) - ccall((:SCIPgetCutEfficacy, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) + ccall( + (:SCIPgetCutEfficacy, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), + scip, + sol, + cut, + ) end function SCIPisCutEfficacious(scip, sol, cut) - ccall((:SCIPisCutEfficacious, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), scip, sol, cut) + ccall( + (:SCIPisCutEfficacious, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_ROW}), + scip, + sol, + cut, + ) end function SCIPisEfficacious(scip, efficacy) - ccall((:SCIPisEfficacious, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, efficacy) + ccall( + (:SCIPisEfficacious, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + efficacy, + ) end function SCIPgetVectorEfficacyNorm(scip, vals, nvals) - ccall((:SCIPgetVectorEfficacyNorm, libscip), Cdouble, (Ptr{SCIP}, Ptr{Cdouble}, Cint), scip, vals, nvals) + ccall( + (:SCIPgetVectorEfficacyNorm, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{Cdouble}, Cint), + scip, + vals, + nvals, + ) end function SCIPisCutApplicable(scip, cut) - ccall((:SCIPisCutApplicable, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, cut) + ccall( + (:SCIPisCutApplicable, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + cut, + ) end function SCIPaddRow(scip, row, forcecut, infeasible) - ccall((:SCIPaddRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cuint, Ptr{Cuint}), scip, row, forcecut, infeasible) + ccall( + (:SCIPaddRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Cuint, Ptr{Cuint}), + scip, + row, + forcecut, + infeasible, + ) end function SCIPisCutNew(scip, row) - ccall((:SCIPisCutNew, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPisCutNew, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPaddPoolCut(scip, row) - ccall((:SCIPaddPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPaddPoolCut, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPdelPoolCut(scip, row) - ccall((:SCIPdelPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPdelPoolCut, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetPoolCuts(scip) @@ -4902,47 +10690,119 @@ function SCIPgetNPoolCuts(scip) end function SCIPgetGlobalCutpool(scip) - ccall((:SCIPgetGlobalCutpool, libscip), Ptr{SCIP_CUTPOOL}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetGlobalCutpool, libscip), + Ptr{SCIP_CUTPOOL}, + (Ptr{SCIP},), + scip, + ) end function SCIPcreateCutpool(scip, cutpool, agelimit) - ccall((:SCIPcreateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}, Cint), scip, cutpool, agelimit) + ccall( + (:SCIPcreateCutpool, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}, Cint), + scip, + cutpool, + agelimit, + ) end function SCIPfreeCutpool(scip, cutpool) - ccall((:SCIPfreeCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}), scip, cutpool) + ccall( + (:SCIPfreeCutpool, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTPOOL}}), + scip, + cutpool, + ) end function SCIPaddRowCutpool(scip, cutpool, row) - ccall((:SCIPaddRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) + ccall( + (:SCIPaddRowCutpool, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), + scip, + cutpool, + row, + ) end function SCIPaddNewRowCutpool(scip, cutpool, row) - ccall((:SCIPaddNewRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) + ccall( + (:SCIPaddNewRowCutpool, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), + scip, + cutpool, + row, + ) end function SCIPdelRowCutpool(scip, cutpool, row) - ccall((:SCIPdelRowCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), scip, cutpool, row) + ccall( + (:SCIPdelRowCutpool, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_ROW}), + scip, + cutpool, + row, + ) end function SCIPseparateCutpool(scip, cutpool, result) - ccall((:SCIPseparateCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_RESULT}), scip, cutpool, result) + ccall( + (:SCIPseparateCutpool, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_RESULT}), + scip, + cutpool, + result, + ) end function SCIPseparateSolCutpool(scip, cutpool, sol, pretendroot, result) - ccall((:SCIPseparateSolCutpool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_RESULT}), scip, cutpool, sol, pretendroot, result) + ccall( + (:SCIPseparateSolCutpool, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTPOOL}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_RESULT}), + scip, + cutpool, + sol, + pretendroot, + result, + ) end function SCIPaddDelayedPoolCut(scip, row) - ccall((:SCIPaddDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPaddDelayedPoolCut, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPdelDelayedPoolCut(scip, row) - ccall((:SCIPdelDelayedPoolCut, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPdelDelayedPoolCut, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetDelayedPoolCuts(scip) - ccall((:SCIPgetDelayedPoolCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetDelayedPoolCuts, libscip), + Ptr{Ptr{SCIP_CUT}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNDelayedPoolCuts(scip) @@ -4950,11 +10810,35 @@ function SCIPgetNDelayedPoolCuts(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}, Cuint, Cuint, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, sol, pretendroot, allowlocal, onlydelayed, delayed, cutoff) + 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}, Cuint, Cuint, Cuint, Ptr{Cuint}, Ptr{Cuint}), + scip, + sol, + pretendroot, + allowlocal, + onlydelayed, + delayed, + cutoff, + ) end function SCIPgetCuts(scip) @@ -4970,159 +10854,419 @@ function SCIPclearCuts(scip) end function SCIPremoveInefficaciousCuts(scip) - ccall((:SCIPremoveInefficaciousCuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPremoveInefficaciousCuts, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPcreateRealarray(scip, realarray) - ccall((:SCIPcreateRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) + ccall( + (:SCIPcreateRealarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), + scip, + realarray, + ) end function SCIPfreeRealarray(scip, realarray) - ccall((:SCIPfreeRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), scip, realarray) + ccall( + (:SCIPfreeRealarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_REALARRAY}}), + scip, + realarray, + ) end function SCIPextendRealarray(scip, realarray, minidx, maxidx) - ccall((:SCIPextendRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cint), scip, realarray, minidx, maxidx) + ccall( + (:SCIPextendRealarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cint), + scip, + realarray, + minidx, + maxidx, + ) end function SCIPclearRealarray(scip, realarray) - ccall((:SCIPclearRealarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) + ccall( + (:SCIPclearRealarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), + scip, + realarray, + ) end function SCIPgetRealarrayVal(scip, realarray, idx) - ccall((:SCIPgetRealarrayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint), scip, realarray, idx) + ccall( + (:SCIPgetRealarrayVal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint), + scip, + realarray, + idx, + ) end function SCIPsetRealarrayVal(scip, realarray, idx, val) - ccall((:SCIPsetRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, val) + ccall( + (:SCIPsetRealarrayVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), + scip, + realarray, + idx, + val, + ) end function SCIPincRealarrayVal(scip, realarray, idx, incval) - ccall((:SCIPincRealarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), scip, realarray, idx, incval) + ccall( + (:SCIPincRealarrayVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_REALARRAY}, Cint, Cdouble), + scip, + realarray, + idx, + incval, + ) end function SCIPgetRealarrayMinIdx(scip, realarray) - ccall((:SCIPgetRealarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) + ccall( + (:SCIPgetRealarrayMinIdx, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), + scip, + realarray, + ) end function SCIPgetRealarrayMaxIdx(scip, realarray) - ccall((:SCIPgetRealarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), scip, realarray) + ccall( + (:SCIPgetRealarrayMaxIdx, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_REALARRAY}), + scip, + realarray, + ) end function SCIPcreateIntarray(scip, intarray) - ccall((:SCIPcreateIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) + ccall( + (:SCIPcreateIntarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), + scip, + intarray, + ) end function SCIPfreeIntarray(scip, intarray) - ccall((:SCIPfreeIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), scip, intarray) + ccall( + (:SCIPfreeIntarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_INTARRAY}}), + scip, + intarray, + ) end function SCIPextendIntarray(scip, intarray, minidx, maxidx) - ccall((:SCIPextendIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, minidx, maxidx) + ccall( + (:SCIPextendIntarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), + scip, + intarray, + minidx, + maxidx, + ) end function SCIPclearIntarray(scip, intarray) - ccall((:SCIPclearIntarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) + ccall( + (:SCIPclearIntarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), + scip, + intarray, + ) end function SCIPgetIntarrayVal(scip, intarray, idx) - ccall((:SCIPgetIntarrayVal, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint), scip, intarray, idx) + ccall( + (:SCIPgetIntarrayVal, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint), + scip, + intarray, + idx, + ) end function SCIPsetIntarrayVal(scip, intarray, idx, val) - ccall((:SCIPsetIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, val) + ccall( + (:SCIPsetIntarrayVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), + scip, + intarray, + idx, + val, + ) end function SCIPincIntarrayVal(scip, intarray, idx, incval) - ccall((:SCIPincIntarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), scip, intarray, idx, incval) + ccall( + (:SCIPincIntarrayVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_INTARRAY}, Cint, Cint), + scip, + intarray, + idx, + incval, + ) end function SCIPgetIntarrayMinIdx(scip, intarray) - ccall((:SCIPgetIntarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) + ccall( + (:SCIPgetIntarrayMinIdx, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), + scip, + intarray, + ) end function SCIPgetIntarrayMaxIdx(scip, intarray) - ccall((:SCIPgetIntarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), scip, intarray) + ccall( + (:SCIPgetIntarrayMaxIdx, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_INTARRAY}), + scip, + intarray, + ) end function SCIPcreateBoolarray(scip, boolarray) - ccall((:SCIPcreateBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) + ccall( + (:SCIPcreateBoolarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), + scip, + boolarray, + ) end function SCIPfreeBoolarray(scip, boolarray) - ccall((:SCIPfreeBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), scip, boolarray) + ccall( + (:SCIPfreeBoolarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_BOOLARRAY}}), + scip, + boolarray, + ) end function SCIPextendBoolarray(scip, boolarray, minidx, maxidx) - ccall((:SCIPextendBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cint), scip, boolarray, minidx, maxidx) + ccall( + (:SCIPextendBoolarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cint), + scip, + boolarray, + minidx, + maxidx, + ) end function SCIPclearBoolarray(scip, boolarray) - ccall((:SCIPclearBoolarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) + ccall( + (:SCIPclearBoolarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), + scip, + boolarray, + ) end function SCIPgetBoolarrayVal(scip, boolarray, idx) - ccall((:SCIPgetBoolarrayVal, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint), scip, boolarray, idx) + ccall( + (:SCIPgetBoolarrayVal, libscip), + Cuint, + (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, Cuint), scip, boolarray, idx, val) + ccall( + (:SCIPsetBoolarrayVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}, Cint, Cuint), + scip, + boolarray, + idx, + val, + ) end function SCIPgetBoolarrayMinIdx(scip, boolarray) - ccall((:SCIPgetBoolarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) + ccall( + (:SCIPgetBoolarrayMinIdx, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), + scip, + boolarray, + ) end function SCIPgetBoolarrayMaxIdx(scip, boolarray) - ccall((:SCIPgetBoolarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), scip, boolarray) + ccall( + (:SCIPgetBoolarrayMaxIdx, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_BOOLARRAY}), + scip, + boolarray, + ) end function SCIPcreatePtrarray(scip, ptrarray) - ccall((:SCIPcreatePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) + ccall( + (:SCIPcreatePtrarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), + scip, + ptrarray, + ) end function SCIPfreePtrarray(scip, ptrarray) - ccall((:SCIPfreePtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), scip, ptrarray) + ccall( + (:SCIPfreePtrarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_PTRARRAY}}), + scip, + ptrarray, + ) end function SCIPextendPtrarray(scip, ptrarray, minidx, maxidx) - ccall((:SCIPextendPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Cint), scip, ptrarray, minidx, maxidx) + ccall( + (:SCIPextendPtrarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Cint), + scip, + ptrarray, + minidx, + maxidx, + ) end function SCIPclearPtrarray(scip, ptrarray) - ccall((:SCIPclearPtrarray, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) + ccall( + (:SCIPclearPtrarray, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), + scip, + ptrarray, + ) end function SCIPgetPtrarrayVal(scip, ptrarray, idx) - ccall((:SCIPgetPtrarrayVal, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint), scip, ptrarray, idx) + ccall( + (:SCIPgetPtrarrayVal, libscip), + Ptr{Cvoid}, + (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint), + scip, + ptrarray, + idx, + ) end function SCIPsetPtrarrayVal(scip, ptrarray, idx, val) - ccall((:SCIPsetPtrarrayVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Ptr{Cvoid}), scip, ptrarray, idx, val) + ccall( + (:SCIPsetPtrarrayVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}, Cint, Ptr{Cvoid}), + scip, + ptrarray, + idx, + val, + ) end function SCIPgetPtrarrayMinIdx(scip, ptrarray) - ccall((:SCIPgetPtrarrayMinIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) + ccall( + (:SCIPgetPtrarrayMinIdx, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), + scip, + ptrarray, + ) end function SCIPgetPtrarrayMaxIdx(scip, ptrarray) - ccall((:SCIPgetPtrarrayMaxIdx, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), scip, ptrarray) + ccall( + (:SCIPgetPtrarrayMaxIdx, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_PTRARRAY}), + scip, + ptrarray, + ) end function SCIPcreateDisjointset(scip, djset, ncomponents) - ccall((:SCIPcreateDisjointset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}, Cint), scip, djset, ncomponents) + ccall( + (:SCIPcreateDisjointset, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}, Cint), + scip, + djset, + ncomponents, + ) end function SCIPfreeDisjointset(scip, djset) - ccall((:SCIPfreeDisjointset, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}), scip, djset) + ccall( + (:SCIPfreeDisjointset, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DISJOINTSET}}), + scip, + djset, + ) end function SCIPcreateDigraph(scip, digraph, nnodes) - ccall((:SCIPcreateDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Cint), scip, digraph, nnodes) + ccall( + (:SCIPcreateDigraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Cint), + scip, + digraph, + nnodes, + ) end function SCIPcopyDigraph(scip, targetdigraph, sourcedigraph) - ccall((:SCIPcopyDigraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Ptr{SCIP_DIGRAPH}), scip, targetdigraph, sourcedigraph) + ccall( + (:SCIPcopyDigraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DIGRAPH}}, Ptr{SCIP_DIGRAPH}), + scip, + targetdigraph, + sourcedigraph, + ) end function SCIPenableDebugSol(scip) @@ -5134,59 +11278,188 @@ function SCIPdisableDebugSol(scip) end function SCIPcreateDecomp(scip, decomp, nblocks, original, benderslabels) - ccall((:SCIPcreateDecomp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DECOMP}}, Cint, Cuint, Cuint), scip, decomp, nblocks, original, benderslabels) + ccall( + (:SCIPcreateDecomp, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DECOMP}}, Cint, Cuint, Cuint), + scip, + decomp, + nblocks, + original, + benderslabels, + ) end function SCIPfreeDecomp(scip, decomp) - ccall((:SCIPfreeDecomp, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_DECOMP}}), scip, decomp) + ccall( + (:SCIPfreeDecomp, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DECOMP}}), + scip, + decomp, + ) end function SCIPaddDecomp(scip, decomp) - ccall((:SCIPaddDecomp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}), scip, decomp) + ccall( + (:SCIPaddDecomp, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DECOMP}), + scip, + decomp, + ) end function SCIPgetDecomps(scip, decomps, ndecomps, original) - ccall((:SCIPgetDecomps, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_DECOMP}}}, Ptr{Cint}, Cuint), scip, decomps, ndecomps, original) + ccall( + (:SCIPgetDecomps, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_DECOMP}}}, Ptr{Cint}, Cuint), + scip, + decomps, + ndecomps, + original, + ) end function SCIPhasConsOnlyLinkVars(scip, decomp, cons, hasonlylinkvars) - ccall((:SCIPhasConsOnlyLinkVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, decomp, cons, hasonlylinkvars) + ccall( + (:SCIPhasConsOnlyLinkVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{SCIP_CONS}, Ptr{Cuint}), + scip, + decomp, + cons, + hasonlylinkvars, + ) end function SCIPcomputeDecompConsLabels(scip, decomp, conss, nconss) - ccall((:SCIPcomputeDecompConsLabels, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint), scip, decomp, conss, nconss) + ccall( + (:SCIPcomputeDecompConsLabels, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint), + scip, + decomp, + conss, + nconss, + ) end function SCIPcomputeDecompVarsLabels(scip, decomp, conss, nconss) - ccall((:SCIPcomputeDecompVarsLabels, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint), scip, decomp, conss, nconss) + ccall( + (:SCIPcomputeDecompVarsLabels, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint), + scip, + decomp, + conss, + nconss, + ) end function SCIPassignDecompLinkConss(scip, decomp, conss, nconss, nskipconss) - ccall((:SCIPassignDecompLinkConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{Cint}), scip, decomp, conss, nconss, nskipconss) + ccall( + (:SCIPassignDecompLinkConss, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{Cint}), + scip, + decomp, + conss, + nconss, + nskipconss, + ) end function SCIPcomputeDecompStats(scip, decomp, uselimits) - ccall((:SCIPcomputeDecompStats, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Cuint), scip, decomp, uselimits) -end - -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}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Ptr{SCIP_DIALOGDATA}), scip, dialog, dialogcopy, dialogexec, dialogdesc, dialogfree, name, desc, issubmenu, dialogdata) + ccall( + (:SCIPcomputeDecompStats, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DECOMP}, Cuint), + scip, + decomp, + uselimits, + ) +end + +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}, + Ptr{Cchar}, + Ptr{Cchar}, + Cuint, + Ptr{SCIP_DIALOGDATA}, + ), + scip, + dialog, + dialogcopy, + dialogexec, + dialogdesc, + dialogfree, + name, + desc, + issubmenu, + dialogdata, + ) end function SCIPexistsDialog(scip, dialog) - ccall((:SCIPexistsDialog, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) + ccall( + (:SCIPexistsDialog, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_DIALOG}), + scip, + dialog, + ) end function SCIPcaptureDialog(scip, dialog) - ccall((:SCIPcaptureDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) + ccall( + (:SCIPcaptureDialog, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DIALOG}), + scip, + dialog, + ) end function SCIPreleaseDialog(scip, dialog) - ccall((:SCIPreleaseDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog) + ccall( + (:SCIPreleaseDialog, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), + scip, + dialog, + ) end function SCIPsetRootDialog(scip, dialog) - ccall((:SCIPsetRootDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) + ccall( + (:SCIPsetRootDialog, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DIALOG}), + scip, + dialog, + ) end function SCIPgetRootDialog(scip) @@ -5194,27 +11467,109 @@ function SCIPgetRootDialog(scip) end function SCIPaddDialogEntry(scip, dialog, subdialog) - ccall((:SCIPaddDialogEntry, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOG}), scip, dialog, subdialog) + ccall( + (:SCIPaddDialogEntry, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOG}), + scip, + dialog, + subdialog, + ) end function SCIPaddDialogInputLine(scip, inputline) - ccall((:SCIPaddDialogInputLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, inputline) + ccall( + (:SCIPaddDialogInputLine, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + inputline, + ) end function SCIPaddDialogHistoryLine(scip, inputline) - ccall((:SCIPaddDialogHistoryLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, inputline) + ccall( + (:SCIPaddDialogHistoryLine, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + inputline, + ) end function SCIPstartInteraction(scip) ccall((:SCIPstartInteraction, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, SCIP_DISPSTATUS, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_DISPDATA}, Cint, Cint, Cint, Cuint), scip, name, desc, header, dispstatus, dispcopy, dispfree, dispinit, dispexit, dispinitsol, dispexitsol, dispoutput, dispdata, width, priority, position, stripline) +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}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cchar}, + SCIP_DISPSTATUS, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_DISPDATA}, + Cint, + Cint, + Cint, + Cuint, + ), + 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}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindDisp, libscip), + Ptr{SCIP_DISP}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetDisps(scip) @@ -5230,51 +11585,183 @@ function SCIPautoselectDisps(scip) end function SCIPchgDispMode(disp, mode) - ccall((:SCIPchgDispMode, libscip), Cvoid, (Ptr{SCIP_DISP}, SCIP_DISPMODE), disp, mode) -end - -function SCIPincludeEventhdlr(scip, name, desc, eventcopy, eventfree, eventinit, eventexit, eventinitsol, eventexitsol, eventdelete, eventexec, eventhdlrdata) - ccall((:SCIPincludeEventhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cvoid}, Ptr{SCIP_EVENTHDLRDATA}), scip, eventhdlrptr, name, desc, eventexec, eventhdlrdata) + ccall( + (:SCIPchgDispMode, libscip), + Cvoid, + (Ptr{SCIP_DISP}, SCIP_DISPMODE), + disp, + mode, + ) +end + +function SCIPincludeEventhdlr( + scip, + name, + desc, + eventcopy, + eventfree, + eventinit, + eventexit, + eventinitsol, + eventexitsol, + eventdelete, + eventexec, + eventhdlrdata, +) + ccall( + (:SCIPincludeEventhdlr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cvoid}, + Ptr{SCIP_EVENTHDLRDATA}, + ), + scip, + eventhdlrptr, + name, + desc, + eventexec, + eventhdlrdata, + ) end function SCIPsetEventhdlrCopy(scip, eventhdlr, eventcopy) - ccall((:SCIPsetEventhdlrCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventcopy) + ccall( + (:SCIPsetEventhdlrCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), + scip, + eventhdlr, + eventcopy, + ) end function SCIPsetEventhdlrFree(scip, eventhdlr, eventfree) - ccall((:SCIPsetEventhdlrFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventfree) + ccall( + (:SCIPsetEventhdlrFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), + scip, + eventhdlr, + eventfree, + ) end function SCIPsetEventhdlrInit(scip, eventhdlr, eventinit) - ccall((:SCIPsetEventhdlrInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinit) + ccall( + (:SCIPsetEventhdlrInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), + scip, + eventhdlr, + eventinit, + ) end function SCIPsetEventhdlrExit(scip, eventhdlr, eventexit) - ccall((:SCIPsetEventhdlrExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexit) + ccall( + (:SCIPsetEventhdlrExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), + scip, + eventhdlr, + eventexit, + ) end function SCIPsetEventhdlrInitsol(scip, eventhdlr, eventinitsol) - ccall((:SCIPsetEventhdlrInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventinitsol) + ccall( + (:SCIPsetEventhdlrInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), + scip, + eventhdlr, + eventinitsol, + ) end function SCIPsetEventhdlrExitsol(scip, eventhdlr, eventexitsol) - ccall((:SCIPsetEventhdlrExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventexitsol) + ccall( + (:SCIPsetEventhdlrExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), + scip, + eventhdlr, + eventexitsol, + ) end function SCIPsetEventhdlrDelete(scip, eventhdlr, eventdelete) - ccall((:SCIPsetEventhdlrDelete, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), scip, eventhdlr, eventdelete) + ccall( + (:SCIPsetEventhdlrDelete, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EVENTHDLR}, Ptr{Cvoid}), + scip, + eventhdlr, + eventdelete, + ) end function SCIPfindEventhdlr(scip, name) - ccall((:SCIPfindEventhdlr, libscip), Ptr{SCIP_EVENTHDLR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindEventhdlr, libscip), + Ptr{SCIP_EVENTHDLR}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetEventhdlrs(scip) - ccall((:SCIPgetEventhdlrs, libscip), Ptr{Ptr{SCIP_EVENTHDLR}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetEventhdlrs, libscip), + Ptr{Ptr{SCIP_EVENTHDLR}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNEventhdlrs(scip) @@ -5282,31 +11769,149 @@ function SCIPgetNEventhdlrs(scip) end function SCIPcatchEvent(scip, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPcatchEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, eventtype, eventhdlr, eventdata, filterpos) + ccall( + (:SCIPcatchEvent, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + SCIP_EVENTTYPE, + Ptr{SCIP_EVENTHDLR}, + Ptr{SCIP_EVENTDATA}, + Ptr{Cint}, + ), + scip, + eventtype, + eventhdlr, + eventdata, + filterpos, + ) end function SCIPdropEvent(scip, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPdropEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), scip, eventtype, eventhdlr, eventdata, filterpos) -end - -function SCIPcatchVarEvent(scip, var, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIPcatchVarEvent, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), scip, var, eventtype, eventhdlr, eventdata, filterpos) + ccall( + (: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) + 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) + 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 function SCIPenableExactSolving(scip, enable) - ccall((:SCIPenableExactSolving, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, enable) + ccall( + (:SCIPenableExactSolving, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint), + scip, + enable, + ) end function SCIPisExact(scip) @@ -5318,19 +11923,55 @@ function SCIPallowNegSlack(scip) end function SCIPbranchLPExact(scip, result) - ccall((:SCIPbranchLPExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RESULT}), scip, result) + ccall( + (:SCIPbranchLPExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RESULT}), + scip, + result, + ) end function SCIPaddRowExact(scip, rowexact) - ccall((:SCIPaddRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}), scip, rowexact) + ccall( + (:SCIPaddRowExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}), + scip, + rowexact, + ) end function SCIPincludeExprhdlr(scip, exprhdlr, name, desc, precedence, eval, data) - ccall((:SCIPincludeExprhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRHDLR}}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Ptr{Cvoid}, Ptr{SCIP_EXPRHDLRDATA}), scip, exprhdlr, name, desc, precedence, eval, data) + ccall( + (:SCIPincludeExprhdlr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPRHDLR}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cuint, + Ptr{Cvoid}, + Ptr{SCIP_EXPRHDLRDATA}, + ), + scip, + exprhdlr, + name, + desc, + precedence, + eval, + data, + ) end function SCIPgetExprhdlrs(scip) - ccall((:SCIPgetExprhdlrs, libscip), Ptr{Ptr{SCIP_EXPRHDLR}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetExprhdlrs, libscip), + Ptr{Ptr{SCIP_EXPRHDLR}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNExprhdlrs(scip) @@ -5338,71 +11979,357 @@ function SCIPgetNExprhdlrs(scip) end function SCIPfindExprhdlr(scip, name) - ccall((:SCIPfindExprhdlr, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindExprhdlr, libscip), + Ptr{SCIP_EXPRHDLR}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetExprhdlrVar(scip) - ccall((:SCIPgetExprhdlrVar, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetExprhdlrVar, libscip), + Ptr{SCIP_EXPRHDLR}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetExprhdlrValue(scip) - ccall((:SCIPgetExprhdlrValue, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetExprhdlrValue, libscip), + Ptr{SCIP_EXPRHDLR}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetExprhdlrSum(scip) - ccall((:SCIPgetExprhdlrSum, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetExprhdlrSum, libscip), + Ptr{SCIP_EXPRHDLR}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetExprhdlrProduct(scip) - ccall((:SCIPgetExprhdlrProduct, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetExprhdlrProduct, libscip), + Ptr{SCIP_EXPRHDLR}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetExprhdlrPower(scip) - ccall((:SCIPgetExprhdlrPower, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP},), scip) -end - -function SCIPcreateExpr(scip, expr, exprhdlr, exprdata, nchildren, children, ownercreate, ownercreatedata) - ccall((:SCIPcreateExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPRHDLR}, Ptr{SCIP_EXPRDATA}, Cint, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, exprhdlr, exprdata, nchildren, children, ownercreate, ownercreatedata) -end - -function SCIPcreateExpr2(scip, expr, exprhdlr, exprdata, child1, child2, ownercreate, ownercreatedata) - ccall((:SCIPcreateExpr2, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPRHDLR}, Ptr{SCIP_EXPRDATA}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, exprhdlr, exprdata, child1, child2, ownercreate, ownercreatedata) -end - -function SCIPcreateExprQuadratic(scip, expr, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, ownercreate, ownercreatedata) -end - -function SCIPcreateExprMonomial(scip, expr, nfactors, vars, exponents, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprMonomial, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, nfactors, vars, exponents, ownercreate, ownercreatedata) + ccall( + (:SCIPgetExprhdlrPower, libscip), + Ptr{SCIP_EXPRHDLR}, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPcreateExpr( + scip, + expr, + exprhdlr, + exprdata, + nchildren, + children, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcreateExpr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPRHDLR}, + Ptr{SCIP_EXPRDATA}, + Cint, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + exprhdlr, + exprdata, + nchildren, + children, + ownercreate, + ownercreatedata, + ) +end + +function SCIPcreateExpr2( + scip, + expr, + exprhdlr, + exprdata, + child1, + child2, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcreateExpr2, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPRHDLR}, + Ptr{SCIP_EXPRDATA}, + Ptr{SCIP_EXPR}, + Ptr{SCIP_EXPR}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + exprhdlr, + exprdata, + child1, + child2, + ownercreate, + ownercreatedata, + ) +end + +function SCIPcreateExprQuadratic( + scip, + expr, + nlinvars, + linvars, + lincoefs, + nquadterms, + quadvars1, + quadvars2, + quadcoefs, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcreateExprQuadratic, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + nlinvars, + linvars, + lincoefs, + nquadterms, + quadvars1, + quadvars2, + quadcoefs, + ownercreate, + ownercreatedata, + ) +end + +function SCIPcreateExprMonomial( + scip, + expr, + nfactors, + vars, + exponents, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcreateExprMonomial, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + nfactors, + vars, + exponents, + ownercreate, + ownercreatedata, + ) end function SCIPappendExprChild(scip, expr, child) - ccall((:SCIPappendExprChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}), scip, expr, child) + ccall( + (:SCIPappendExprChild, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}), + scip, + expr, + child, + ) end function SCIPreplaceExprChild(scip, expr, childidx, newchild) - ccall((:SCIPreplaceExprChild, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cint, Ptr{SCIP_EXPR}), scip, expr, childidx, newchild) + ccall( + (:SCIPreplaceExprChild, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cint, Ptr{SCIP_EXPR}), + scip, + expr, + childidx, + newchild, + ) end function SCIPremoveExprChildren(scip, expr) - ccall((:SCIPremoveExprChildren, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) -end - -function SCIPduplicateExpr(scip, expr, copyexpr, mapexpr, mapexprdata, ownercreate, ownercreatedata) - ccall((:SCIPduplicateExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, copyexpr, mapexpr, mapexprdata, ownercreate, ownercreatedata) -end - -function SCIPduplicateExprShallow(scip, expr, copyexpr, ownercreate, ownercreatedata) - ccall((:SCIPduplicateExprShallow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, copyexpr, ownercreate, ownercreatedata) -end - -function SCIPcopyExpr(sourcescip, targetscip, expr, copyexpr, ownercreate, ownercreatedata, varmap, consmap, _global, valid) - ccall((:SCIPcopyExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cuint, Ptr{Cuint}), sourcescip, targetscip, expr, copyexpr, ownercreate, ownercreatedata, varmap, consmap, _global, valid) -end - -function SCIPparseExpr(scip, expr, exprstr, finalpos, ownercreate, ownercreatedata) - ccall((:SCIPparseExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, exprstr, finalpos, ownercreate, ownercreatedata) + ccall( + (:SCIPremoveExprChildren, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) +end + +function SCIPduplicateExpr( + scip, + expr, + copyexpr, + mapexpr, + mapexprdata, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPduplicateExpr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + copyexpr, + mapexpr, + mapexprdata, + ownercreate, + ownercreatedata, + ) +end + +function SCIPduplicateExprShallow( + scip, + expr, + copyexpr, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPduplicateExprShallow, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + copyexpr, + ownercreate, + ownercreatedata, + ) +end + +function SCIPcopyExpr( + sourcescip, + targetscip, + expr, + copyexpr, + ownercreate, + ownercreatedata, + varmap, + consmap, + _global, + valid, +) + ccall( + (:SCIPcopyExpr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Cuint, + Ptr{Cuint}, + ), + sourcescip, + targetscip, + expr, + copyexpr, + ownercreate, + ownercreatedata, + varmap, + consmap, + _global, + valid, + ) +end + +function SCIPparseExpr( + scip, + expr, + exprstr, + finalpos, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPparseExpr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cchar}, + Ptr{Ptr{Cchar}}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + exprstr, + finalpos, + ownercreate, + ownercreatedata, + ) end function SCIPcaptureExpr(expr) @@ -5410,59 +12337,162 @@ function SCIPcaptureExpr(expr) end function SCIPreleaseExpr(scip, expr) - ccall((:SCIPreleaseExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}), scip, expr) + ccall( + (:SCIPreleaseExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}), + scip, + expr, + ) end function SCIPisExprVar(scip, expr) - ccall((:SCIPisExprVar, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprVar, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPisExprValue(scip, expr) - ccall((:SCIPisExprValue, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprValue, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPisExprSum(scip, expr) - ccall((:SCIPisExprSum, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprSum, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPisExprProduct(scip, expr) - ccall((:SCIPisExprProduct, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprProduct, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPisExprPower(scip, expr) - ccall((:SCIPisExprPower, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprPower, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPprintExpr(scip, expr, file) - ccall((:SCIPprintExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Libc.FILE}), scip, expr, file) + ccall( + (:SCIPprintExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Libc.FILE}), + scip, + expr, + file, + ) end function SCIPprintExprDotInit(scip, printdata, file, whattoprint) - ccall((:SCIPprintExprDotInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRPRINTDATA}}, Ptr{Libc.FILE}, SCIP_EXPRPRINT_WHAT), scip, printdata, file, whattoprint) + ccall( + (:SCIPprintExprDotInit, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPRPRINTDATA}}, + Ptr{Libc.FILE}, + SCIP_EXPRPRINT_WHAT, + ), + scip, + printdata, + file, + whattoprint, + ) end function SCIPprintExprDotInit2(scip, printdata, filename, whattoprint) - ccall((:SCIPprintExprDotInit2, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRPRINTDATA}}, Ptr{Cchar}, SCIP_EXPRPRINT_WHAT), scip, printdata, filename, whattoprint) + ccall( + (:SCIPprintExprDotInit2, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPRPRINTDATA}}, + Ptr{Cchar}, + SCIP_EXPRPRINT_WHAT, + ), + scip, + printdata, + filename, + whattoprint, + ) end function SCIPprintExprDot(scip, printdata, expr) - ccall((:SCIPprintExprDot, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPRPRINTDATA}, Ptr{SCIP_EXPR}), scip, printdata, expr) + ccall( + (:SCIPprintExprDot, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPRPRINTDATA}, Ptr{SCIP_EXPR}), + scip, + printdata, + expr, + ) end function SCIPprintExprDotFinal(scip, printdata) - ccall((:SCIPprintExprDotFinal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRPRINTDATA}}), scip, printdata) + ccall( + (:SCIPprintExprDotFinal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRPRINTDATA}}), + scip, + printdata, + ) end function SCIPshowExpr(scip, expr) - ccall((:SCIPshowExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPshowExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPdismantleExpr(scip, file, expr) - ccall((:SCIPdismantleExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_EXPR}), scip, file, expr) + ccall( + (:SCIPdismantleExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_EXPR}), + scip, + file, + expr, + ) end function SCIPevalExpr(scip, expr, sol, soltag) - ccall((:SCIPevalExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong), scip, expr, sol, soltag) + ccall( + (:SCIPevalExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong), + scip, + expr, + sol, + soltag, + ) end function SCIPgetExprNewSoltag(scip) @@ -5470,127 +12500,499 @@ function SCIPgetExprNewSoltag(scip) end function SCIPevalExprGradient(scip, expr, sol, soltag) - ccall((:SCIPevalExprGradient, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong), scip, expr, sol, soltag) + ccall( + (:SCIPevalExprGradient, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong), + scip, + expr, + sol, + soltag, + ) end function SCIPevalExprHessianDir(scip, expr, sol, soltag, direction) - ccall((:SCIPevalExprHessianDir, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong, Ptr{SCIP_SOL}), scip, expr, sol, soltag, direction) + ccall( + (:SCIPevalExprHessianDir, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong, Ptr{SCIP_SOL}), + scip, + expr, + sol, + soltag, + direction, + ) end function SCIPevalExprActivity(scip, expr) - ccall((:SCIPevalExprActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPevalExprActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPcompareExpr(scip, expr1, expr2) - ccall((:SCIPcompareExpr, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}), scip, expr1, expr2) + ccall( + (:SCIPcompareExpr, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}), + scip, + expr1, + expr2, + ) end function SCIPhashExpr(scip, expr, hashval) - ccall((:SCIPhashExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cuint}), scip, expr, hashval) -end - -function SCIPsimplifyExpr(scip, rootexpr, simplified, changed, infeasible, ownercreate, ownercreatedata) - ccall((:SCIPsimplifyExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}), scip, rootexpr, simplified, changed, infeasible, ownercreate, ownercreatedata) + ccall( + (:SCIPhashExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cuint}), + scip, + expr, + hashval, + ) +end + +function SCIPsimplifyExpr( + scip, + rootexpr, + simplified, + changed, + infeasible, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPsimplifyExpr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + rootexpr, + simplified, + changed, + infeasible, + ownercreate, + ownercreatedata, + ) end function SCIPgetSymDataExpr(scip, expr, symdata) - ccall((:SCIPgetSymDataExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SYM_EXPRDATA}}), scip, expr, symdata) + ccall( + (:SCIPgetSymDataExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SYM_EXPRDATA}}), + scip, + expr, + symdata, + ) end function SCIPreplaceCommonSubexpressions(scip, exprs, nexprs, replacedroot) - ccall((:SCIPreplaceCommonSubexpressions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Cuint}), scip, exprs, nexprs, replacedroot) + ccall( + (:SCIPreplaceCommonSubexpressions, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Cuint}), + scip, + exprs, + nexprs, + replacedroot, + ) end function SCIPcomputeExprCurvature(scip, expr) - ccall((:SCIPcomputeExprCurvature, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPcomputeExprCurvature, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPcomputeExprIntegrality(scip, expr) - ccall((:SCIPcomputeExprIntegrality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPcomputeExprIntegrality, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPgetExprNVars(scip, expr, nvars) - ccall((:SCIPgetExprNVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cint}), scip, expr, nvars) + ccall( + (:SCIPgetExprNVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cint}), + scip, + expr, + nvars, + ) end function SCIPgetExprVarExprs(scip, expr, varexprs, nvarexprs) - ccall((:SCIPgetExprVarExprs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cint}), scip, expr, varexprs, nvarexprs) -end - -function SCIPcallExprPrint(scip, expr, stage, currentchild, parentprecedence, file) - ccall((:SCIPcallExprPrint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_STAGE, Cint, Cuint, Ptr{Libc.FILE}), scip, expr, stage, currentchild, parentprecedence, file) + ccall( + (:SCIPgetExprVarExprs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cint}), + scip, + expr, + varexprs, + nvarexprs, + ) +end + +function SCIPcallExprPrint( + scip, + expr, + stage, + currentchild, + parentprecedence, + file, +) + ccall( + (:SCIPcallExprPrint, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + SCIP_EXPRITER_STAGE, + Cint, + Cuint, + Ptr{Libc.FILE}, + ), + scip, + expr, + stage, + currentchild, + parentprecedence, + file, + ) end function SCIPcallExprCurvature(scip, expr, exprcurvature, success, childcurv) - ccall((:SCIPcallExprCurvature, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_EXPRCURV, Ptr{Cuint}, Ptr{SCIP_EXPRCURV}), scip, expr, exprcurvature, success, childcurv) + ccall( + (:SCIPcallExprCurvature, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + SCIP_EXPRCURV, + Ptr{Cuint}, + Ptr{SCIP_EXPRCURV}, + ), + scip, + expr, + exprcurvature, + success, + childcurv, + ) end function SCIPcallExprMonotonicity(scip, expr, childidx, result) - ccall((:SCIPcallExprMonotonicity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cint, Ptr{SCIP_MONOTONE}), scip, expr, childidx, result) + ccall( + (:SCIPcallExprMonotonicity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cint, Ptr{SCIP_MONOTONE}), + scip, + expr, + childidx, + result, + ) end function SCIPcallExprEval(scip, expr, childrenvalues, val) - ccall((:SCIPcallExprEval, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cdouble}), scip, expr, childrenvalues, val) + ccall( + (:SCIPcallExprEval, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cdouble}), + scip, + expr, + childrenvalues, + val, + ) end function SCIPcallExprEvalFwdiff(scip, expr, childrenvalues, direction, val, dot) - ccall((:SCIPcallExprEvalFwdiff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), scip, expr, childrenvalues, direction, val, dot) + ccall( + (:SCIPcallExprEvalFwdiff, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + scip, + expr, + childrenvalues, + direction, + val, + dot, + ) end function SCIPcallExprInteval(scip, expr, interval, intevalvar, intevalvardata) - ccall((:SCIPcallExprInteval, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_INTERVAL}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, interval, intevalvar, intevalvardata) -end - -function SCIPcallExprEstimate(scip, expr, localbounds, globalbounds, refpoint, overestimate, targetvalue, coefs, constant, islocal, success, branchcand) - ccall((:SCIPcallExprEstimate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_INTERVAL}, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}, Cuint, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, expr, localbounds, globalbounds, refpoint, overestimate, targetvalue, coefs, constant, islocal, success, branchcand) -end - -function SCIPcallExprInitestimates(scip, expr, bounds, overestimate, coefs, constant, nreturned) - ccall((:SCIPcallExprInitestimates, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_INTERVAL}, Cuint, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}), scip, expr, bounds, overestimate, coefs, constant, nreturned) -end - -function SCIPcallExprSimplify(scip, expr, simplifiedexpr, ownercreate, ownercreatedata) - ccall((:SCIPcallExprSimplify, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, simplifiedexpr, ownercreate, ownercreatedata) + ccall( + (:SCIPcallExprInteval, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_INTERVAL}, Ptr{Cvoid}, Ptr{Cvoid}), + scip, + expr, + interval, + intevalvar, + intevalvardata, + ) +end + +function SCIPcallExprEstimate( + scip, + expr, + localbounds, + globalbounds, + refpoint, + overestimate, + targetvalue, + coefs, + constant, + islocal, + success, + branchcand, +) + ccall( + (:SCIPcallExprEstimate, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{SCIP_INTERVAL}, + Ptr{SCIP_INTERVAL}, + Ptr{Cdouble}, + Cuint, + Cdouble, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + expr, + localbounds, + globalbounds, + refpoint, + overestimate, + targetvalue, + coefs, + constant, + islocal, + success, + branchcand, + ) +end + +function SCIPcallExprInitestimates( + scip, + expr, + bounds, + overestimate, + coefs, + constant, + nreturned, +) + ccall( + (:SCIPcallExprInitestimates, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{SCIP_INTERVAL}, + Cuint, + Ptr{Ptr{Cdouble}}, + Ptr{Cdouble}, + Ptr{Cint}, + ), + scip, + expr, + bounds, + overestimate, + coefs, + constant, + nreturned, + ) +end + +function SCIPcallExprSimplify( + scip, + expr, + simplifiedexpr, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcallExprSimplify, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + simplifiedexpr, + ownercreate, + ownercreatedata, + ) end function SCIPcallExprReverseprop(scip, expr, bounds, childrenbounds, infeasible) - ccall((:SCIPcallExprReverseprop, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_INTERVAL, Ptr{SCIP_INTERVAL}, Ptr{Cuint}), scip, expr, bounds, childrenbounds, infeasible) + ccall( + (:SCIPcallExprReverseprop, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + SCIP_INTERVAL, + Ptr{SCIP_INTERVAL}, + Ptr{Cuint}, + ), + scip, + expr, + bounds, + childrenbounds, + infeasible, + ) end function SCIPcallExprGetSymData(scip, expr, symdata) - ccall((:SCIPcallExprGetSymData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SYM_EXPRDATA}}), scip, expr, symdata) + ccall( + (:SCIPcallExprGetSymData, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Ptr{SYM_EXPRDATA}}), + scip, + expr, + symdata, + ) end function SCIPcreateExpriter(scip, iterator) - ccall((:SCIPcreateExpriter, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRITER}}), scip, iterator) + ccall( + (:SCIPcreateExpriter, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPRITER}}), + scip, + iterator, + ) end function SCIPfreeExpriter(iterator) - ccall((:SCIPfreeExpriter, libscip), Cvoid, (Ptr{Ptr{SCIP_EXPRITER}},), iterator) + ccall( + (:SCIPfreeExpriter, libscip), + Cvoid, + (Ptr{Ptr{SCIP_EXPRITER}},), + iterator, + ) end function SCIPcheckExprQuadratic(scip, expr, isquadratic) - ccall((:SCIPcheckExprQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cuint}), scip, expr, isquadratic) + ccall( + (:SCIPcheckExprQuadratic, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cuint}), + scip, + expr, + isquadratic, + ) end function SCIPfreeExprQuadratic(scip, expr) - ccall((:SCIPfreeExprQuadratic, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPfreeExprQuadratic, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPevalExprQuadratic(scip, expr, sol) - ccall((:SCIPevalExprQuadratic, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}), scip, expr, sol) + ccall( + (:SCIPevalExprQuadratic, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}), + scip, + expr, + sol, + ) end function SCIPprintExprQuadratic(scip, expr) - ccall((:SCIPprintExprQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) -end - -function SCIPcomputeExprQuadraticCurvature(scip, expr, curv, assumevarfixed, storeeigeninfo) - ccall((:SCIPcomputeExprQuadraticCurvature, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPRCURV}, Ptr{SCIP_HASHMAP}, Cuint), scip, expr, curv, assumevarfixed, storeeigeninfo) + ccall( + (:SCIPprintExprQuadratic, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) +end + +function SCIPcomputeExprQuadraticCurvature( + scip, + expr, + curv, + assumevarfixed, + storeeigeninfo, +) + ccall( + (:SCIPcomputeExprQuadraticCurvature, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{SCIP_EXPRCURV}, + Ptr{SCIP_HASHMAP}, + Cuint, + ), + scip, + expr, + curv, + assumevarfixed, + storeeigeninfo, + ) end function SCIPgetExprMonomialData(scip, expr, coef, exponents, factors) - ccall((:SCIPgetExprMonomialData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{SCIP_EXPR}}), scip, expr, coef, exponents, factors) + ccall( + (:SCIPgetExprMonomialData, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Ptr{SCIP_EXPR}}, + ), + scip, + expr, + coef, + exponents, + factors, + ) end function SCIPversion() @@ -5614,11 +13016,23 @@ function SCIPsubversion() end function SCIPprintVersion(scip, file) - ccall((:SCIPprintVersion, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintVersion, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPprintBuildOptions(scip, file) - ccall((:SCIPprintBuildOptions, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintBuildOptions, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPprintError(retcode) @@ -5638,7 +13052,13 @@ function SCIPgetStage(scip) end function SCIPprintStage(scip, file) - ccall((:SCIPprintStage, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintStage, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPgetStatus(scip) @@ -5650,7 +13070,13 @@ function SCIPstatusName(status) end function SCIPprintStatus(scip, file) - ccall((:SCIPprintStatus, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintStatus, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPisTransformed(scip) @@ -5674,15 +13100,32 @@ function SCIPisStopped(scip) end function SCIPincludeExternalCodeInformation(scip, name, description) - ccall((:SCIPincludeExternalCodeInformation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, name, description) + ccall( + (:SCIPincludeExternalCodeInformation, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), + scip, + name, + description, + ) end function SCIPgetExternalCodeNames(scip) - ccall((:SCIPgetExternalCodeNames, libscip), Ptr{Ptr{Cchar}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetExternalCodeNames, libscip), + Ptr{Ptr{Cchar}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetExternalCodeDescriptions(scip) - ccall((:SCIPgetExternalCodeDescriptions, libscip), Ptr{Ptr{Cchar}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetExternalCodeDescriptions, libscip), + Ptr{Ptr{Cchar}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNExternalCodes(scip) @@ -5690,43 +13133,202 @@ function SCIPgetNExternalCodes(scip) end function SCIPprintExternalCodes(scip, file) - ccall((:SCIPprintExternalCodes, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) -end - -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}, Ptr{Cchar}, Ptr{Cchar}, Cchar, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cchar, Cint, Cint, Cint, Cint, SCIP_HEURTIMING, Cuint, Ptr{Cvoid}, Ptr{SCIP_HEURDATA}), scip, heur, name, desc, dispchar, priority, freq, freqofs, maxdepth, timingmask, usessubscip, heurexec, heurdata) + ccall( + (:SCIPprintExternalCodes, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) +end + +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}, + Ptr{Cchar}, + Ptr{Cchar}, + Cchar, + Cint, + Cint, + Cint, + Cint, + SCIP_HEURTIMING, + Cuint, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cchar, + Cint, + Cint, + Cint, + Cint, + SCIP_HEURTIMING, + Cuint, + Ptr{Cvoid}, + Ptr{SCIP_HEURDATA}, + ), + scip, + heur, + name, + desc, + dispchar, + priority, + freq, + freqofs, + maxdepth, + timingmask, + usessubscip, + heurexec, + heurdata, + ) end function SCIPsetHeurCopy(scip, heur, heurcopy) - ccall((:SCIPsetHeurCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurcopy) + ccall( + (:SCIPsetHeurCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), + scip, + heur, + heurcopy, + ) end function SCIPsetHeurFree(scip, heur, heurfree) - ccall((:SCIPsetHeurFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurfree) + ccall( + (:SCIPsetHeurFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), + scip, + heur, + heurfree, + ) end function SCIPsetHeurInit(scip, heur, heurinit) - ccall((:SCIPsetHeurInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinit) + ccall( + (:SCIPsetHeurInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), + scip, + heur, + heurinit, + ) end function SCIPsetHeurExit(scip, heur, heurexit) - ccall((:SCIPsetHeurExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexit) + ccall( + (:SCIPsetHeurExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), + scip, + heur, + heurexit, + ) end function SCIPsetHeurInitsol(scip, heur, heurinitsol) - ccall((:SCIPsetHeurInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurinitsol) + ccall( + (:SCIPsetHeurInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), + scip, + heur, + heurinitsol, + ) end function SCIPsetHeurExitsol(scip, heur, heurexitsol) - ccall((:SCIPsetHeurExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), scip, heur, heurexitsol) + ccall( + (:SCIPsetHeurExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cvoid}), + scip, + heur, + heurexitsol, + ) end function SCIPfindHeur(scip, name) - ccall((:SCIPfindHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindHeur, libscip), + Ptr{SCIP_HEUR}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetHeurs(scip) @@ -5738,31 +13340,185 @@ function SCIPgetNHeurs(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, ispublic, specificsos1score, divesetgetscore, divesetavailable) - ccall((:SCIPcreateDiveset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIVESET}}, Ptr{SCIP_HEUR}, Ptr{Cchar}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}), scip, diveset, heur, name, minreldepth, maxreldepth, maxlpiterquot, maxdiveubquot, maxdiveavgquot, maxdiveubquotnosol, maxdiveavgquotnosol, lpresolvedomchgquot, lpsolvefreq, maxlpiterofs, initialseed, backtrack, onlylpbranchcands, ispublic, specificsos1score, divesetgetscore, divesetavailable) + 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, + ispublic, + specificsos1score, + divesetgetscore, + divesetavailable, +) + ccall( + (:SCIPcreateDiveset, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_DIVESET}}, + Ptr{SCIP_HEUR}, + Ptr{Cchar}, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cint, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + diveset, + heur, + name, + minreldepth, + maxreldepth, + maxlpiterquot, + maxdiveubquot, + maxdiveavgquot, + maxdiveubquotnosol, + maxdiveavgquotnosol, + lpresolvedomchgquot, + lpsolvefreq, + maxlpiterofs, + initialseed, + backtrack, + onlylpbranchcands, + ispublic, + specificsos1score, + divesetgetscore, + divesetavailable, + ) end function SCIPisDivesetAvailable(scip, diveset, available) - ccall((:SCIPisDivesetAvailable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{Cuint}), scip, diveset, available) -end - -function SCIPincludeIISfinder(scip, name, desc, priority, iisfindercopy, iisfinderfree, iisfinderexec, iisfinderdata) - ccall((:SCIPincludeIISfinder, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_IISFINDERDATA}), scip, name, desc, priority, iisfindercopy, iisfinderfree, iisfinderexec, iisfinderdata) -end - -function SCIPincludeIISfinderBasic(scip, iisfinder, name, desc, priority, iisfinderexec, iisfinderdata) - ccall((:SCIPincludeIISfinderBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_IISFINDER}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{SCIP_IISFINDERDATA}), scip, iisfinder, name, desc, priority, iisfinderexec, iisfinderdata) + ccall( + (:SCIPisDivesetAvailable, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{Cuint}), + scip, + diveset, + available, + ) +end + +function SCIPincludeIISfinder( + scip, + name, + desc, + priority, + iisfindercopy, + iisfinderfree, + iisfinderexec, + iisfinderdata, +) + ccall( + (:SCIPincludeIISfinder, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_IISFINDERDATA}, + ), + scip, + name, + desc, + priority, + iisfindercopy, + iisfinderfree, + iisfinderexec, + iisfinderdata, + ) +end + +function SCIPincludeIISfinderBasic( + scip, + iisfinder, + name, + desc, + priority, + iisfinderexec, + iisfinderdata, +) + ccall( + (:SCIPincludeIISfinderBasic, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_IISFINDER}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Ptr{Cvoid}, + Ptr{SCIP_IISFINDERDATA}, + ), + scip, + iisfinder, + name, + desc, + priority, + iisfinderexec, + iisfinderdata, + ) end function SCIPsetIISfinderCopy(scip, iisfinder, iisfindercopy) - ccall((:SCIPsetIISfinderCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Ptr{Cvoid}), scip, iisfinder, iisfindercopy) + ccall( + (:SCIPsetIISfinderCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Ptr{Cvoid}), + scip, + iisfinder, + iisfindercopy, + ) end function SCIPsetIISfinderFree(scip, iisfinder, iisfinderfree) - ccall((:SCIPsetIISfinderFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Ptr{Cvoid}), scip, iisfinder, iisfinderfree) + ccall( + (:SCIPsetIISfinderFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Ptr{Cvoid}), + scip, + iisfinder, + iisfinderfree, + ) end function SCIPgenerateIIS(scip) @@ -5770,11 +13526,22 @@ function SCIPgenerateIIS(scip) end function SCIPfindIISfinder(scip, name) - ccall((:SCIPfindIISfinder, libscip), Ptr{SCIP_IISFINDER}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindIISfinder, libscip), + Ptr{SCIP_IISFINDER}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetIISfinders(scip) - ccall((:SCIPgetIISfinders, libscip), Ptr{Ptr{SCIP_IISFINDER}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetIISfinders, libscip), + Ptr{Ptr{SCIP_IISFINDER}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNIISfinders(scip) @@ -5782,7 +13549,14 @@ function SCIPgetNIISfinders(scip) end function SCIPsetIISfinderPriority(scip, iisfinder, priority) - ccall((:SCIPsetIISfinderPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Cint), scip, iisfinder, priority) + ccall( + (:SCIPsetIISfinderPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_IISFINDER}, Cint), + scip, + iisfinder, + priority, + ) end function SCIPgetIIS(scip) @@ -5798,7 +13572,13 @@ function SCIPisLPConstructed(scip) end function SCIPconstructLP(scip, cutoff) - ccall((:SCIPconstructLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, cutoff) + ccall( + (:SCIPconstructLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}), + scip, + cutoff, + ) end function SCIPflushLP(scip) @@ -5862,7 +13642,13 @@ function SCIPgetLPFeastol(scip) end function SCIPsetLPFeastol(scip, newfeastol) - ccall((:SCIPsetLPFeastol, libscip), Cvoid, (Ptr{SCIP}, Cdouble), scip, newfeastol) + ccall( + (:SCIPsetLPFeastol, libscip), + Cvoid, + (Ptr{SCIP}, Cdouble), + scip, + newfeastol, + ) end function SCIPresetLPFeastol(scip) @@ -5870,7 +13656,14 @@ function SCIPresetLPFeastol(scip) end function SCIPgetLPColsData(scip, cols, ncols) - ccall((:SCIPgetLPColsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_COL}}}, Ptr{Cint}), scip, cols, ncols) + ccall( + (:SCIPgetLPColsData, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_COL}}}, Ptr{Cint}), + scip, + cols, + ncols, + ) end function SCIPgetLPCols(scip) @@ -5886,7 +13679,14 @@ function SCIPgetNUnfixedLPCols(scip) end function SCIPgetLPRowsData(scip, rows, nrows) - ccall((:SCIPgetLPRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_ROW}}}, Ptr{Cint}), scip, rows, nrows) + ccall( + (:SCIPgetLPRowsData, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_ROW}}}, Ptr{Cint}), + scip, + rows, + nrows, + ) end function SCIPgetLPRows(scip) @@ -5906,219 +13706,889 @@ function SCIPisLPSolBasic(scip) end function SCIPgetLPBasisInd(scip, basisind) - ccall((:SCIPgetLPBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, basisind) + ccall( + (:SCIPgetLPBasisInd, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cint}), + scip, + basisind, + ) end function SCIPgetLPBInvRow(scip, r, coefs, inds, ninds) - ccall((:SCIPgetLPBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, coefs, inds, ninds) + ccall( + (:SCIPgetLPBInvRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + scip, + r, + coefs, + inds, + ninds, + ) end function SCIPgetLPBInvCol(scip, c, coefs, inds, ninds) - ccall((:SCIPgetLPBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) + ccall( + (:SCIPgetLPBInvCol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + scip, + c, + coefs, + inds, + ninds, + ) end function SCIPgetLPBInvARow(scip, r, binvrow, coefs, inds, ninds) - ccall((:SCIPgetLPBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, r, binvrow, coefs, inds, ninds) + ccall( + (:SCIPgetLPBInvARow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + scip, + r, + binvrow, + coefs, + inds, + ninds, + ) end function SCIPgetLPBInvACol(scip, c, coefs, inds, ninds) - ccall((:SCIPgetLPBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), scip, c, coefs, inds, ninds) + ccall( + (:SCIPgetLPBInvACol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + scip, + c, + coefs, + inds, + ninds, + ) end function SCIPsumLPRows(scip, weights, sumcoef, sumlhs, sumrhs) - ccall((:SCIPsumLPRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}, Ptr{SCIP_REALARRAY}, Ptr{Cdouble}, Ptr{Cdouble}), scip, weights, sumcoef, sumlhs, sumrhs) + ccall( + (:SCIPsumLPRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cdouble}, + Ptr{SCIP_REALARRAY}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + scip, + weights, + sumcoef, + sumlhs, + sumrhs, + ) end function SCIPinterruptLP(scip, interrupt) - ccall((:SCIPinterruptLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, interrupt) + ccall( + (:SCIPinterruptLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint), + scip, + interrupt, + ) end function SCIPwriteLP(scip, filename) - ccall((:SCIPwriteLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) + ccall( + (:SCIPwriteLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + filename, + ) end function SCIPwriteMIP(scip, filename, genericnames, origobj, lazyconss) - ccall((:SCIPwriteMIP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cuint, Cuint, Cuint), scip, filename, genericnames, origobj, lazyconss) + ccall( + (:SCIPwriteMIP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Cuint, Cuint, Cuint), + scip, + filename, + genericnames, + origobj, + lazyconss, + ) end function SCIPgetLPI(scip, lpi) - ccall((:SCIPgetLPI, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LPI}}), scip, lpi) + ccall( + (:SCIPgetLPI, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_LPI}}), + scip, + lpi, + ) end function SCIPprintLPSolutionQuality(scip, file) - ccall((:SCIPprintLPSolutionQuality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) -end - -function SCIPcomputeLPRelIntPoint(scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) - ccall((:SCIPcomputeLPRelIntPoint, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Cuint, Cdouble, Cint, Ptr{Ptr{SCIP_SOL}}), scip, relaxrows, inclobjcutoff, timelimit, iterlimit, point) + ccall( + (:SCIPprintLPSolutionQuality, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) +end + +function SCIPcomputeLPRelIntPoint( + scip, + relaxrows, + inclobjcutoff, + timelimit, + iterlimit, + point, +) + ccall( + (:SCIPcomputeLPRelIntPoint, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint, Cuint, Cdouble, Cint, Ptr{Ptr{SCIP_SOL}}), + scip, + relaxrows, + inclobjcutoff, + timelimit, + iterlimit, + point, + ) end function SCIPgetColRedcost(scip, col) - ccall((:SCIPgetColRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) + ccall( + (:SCIPgetColRedcost, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_COL}), + scip, + col, + ) end function SCIPgetColFarkasCoef(scip, col) - ccall((:SCIPgetColFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) + ccall( + (:SCIPgetColFarkasCoef, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_COL}), + scip, + col, + ) end function SCIPmarkColNotRemovableLocal(scip, col) - ccall((:SCIPmarkColNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_COL}), scip, col) -end - -function SCIPcreateRowConshdlr(scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateRowConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, conshdlr, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) -end - -function SCIPcreateRowCons(scip, row, cons, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONS}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, cons, 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}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, name, len, cols, vals, lhs, rhs, _local, modifiable, removable) -end - -function SCIPcreateEmptyRowConshdlr(scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateEmptyRowConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONSHDLR}, Ptr{Cchar}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, conshdlr, name, lhs, rhs, _local, modifiable, removable) -end - -function SCIPcreateEmptyRowCons(scip, row, cons, name, lhs, rhs, _local, modifiable, removable) - ccall((:SCIPcreateEmptyRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CONS}, Ptr{Cchar}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, cons, 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}, Ptr{Cchar}, Cdouble, Cdouble, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cdouble, Cdouble, Cuint, Cuint, Cuint), scip, row, name, lhs, rhs, _local, modifiable, removable) + ccall( + (:SCIPmarkColNotRemovableLocal, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_COL}), + scip, + col, + ) +end + +function SCIPcreateRowConshdlr( + scip, + row, + conshdlr, + name, + len, + cols, + vals, + lhs, + rhs, + _local, + modifiable, + removable, +) + ccall( + (:SCIPcreateRowConshdlr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{SCIP_CONSHDLR}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_COL}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + ), + scip, + row, + conshdlr, + name, + len, + cols, + vals, + lhs, + rhs, + _local, + modifiable, + removable, + ) +end + +function SCIPcreateRowCons( + scip, + row, + cons, + name, + len, + cols, + vals, + lhs, + rhs, + _local, + modifiable, + removable, +) + ccall( + (:SCIPcreateRowCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{SCIP_CONS}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_COL}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + ), + scip, + row, + cons, + 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}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_COL}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_COL}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + ), + scip, + row, + name, + len, + cols, + vals, + lhs, + rhs, + _local, + modifiable, + removable, + ) +end + +function SCIPcreateEmptyRowConshdlr( + scip, + row, + conshdlr, + name, + lhs, + rhs, + _local, + modifiable, + removable, +) + ccall( + (:SCIPcreateEmptyRowConshdlr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{SCIP_CONSHDLR}, + Ptr{Cchar}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + ), + scip, + row, + conshdlr, + name, + lhs, + rhs, + _local, + modifiable, + removable, + ) +end + +function SCIPcreateEmptyRowCons( + scip, + row, + cons, + name, + lhs, + rhs, + _local, + modifiable, + removable, +) + ccall( + (:SCIPcreateEmptyRowCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{SCIP_CONS}, + Ptr{Cchar}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + ), + scip, + row, + cons, + 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}, + Ptr{Cchar}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + ), + scip, + row, + name, + lhs, + rhs, + _local, + modifiable, + removable, + ) end function SCIPcaptureRow(scip, row) - ccall((:SCIPcaptureRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPcaptureRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPreleaseRow(scip, row) - ccall((:SCIPreleaseRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}), scip, row) + ccall( + (:SCIPreleaseRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}), + scip, + row, + ) end function SCIPchgRowLhs(scip, row, lhs) - ccall((:SCIPchgRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, lhs) + ccall( + (:SCIPchgRowLhs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), + scip, + row, + lhs, + ) end function SCIPchgRowRhs(scip, row, rhs) - ccall((:SCIPchgRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, rhs) + ccall( + (:SCIPchgRowRhs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), + scip, + row, + rhs, + ) end function SCIPcacheRowExtensions(scip, row) - ccall((:SCIPcacheRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPcacheRowExtensions, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPflushRowExtensions(scip, row) - ccall((:SCIPflushRowExtensions, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPflushRowExtensions, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPaddVarToRow(scip, row, var, val) - ccall((:SCIPaddVarToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_VAR}, Cdouble), scip, row, var, val) + ccall( + (:SCIPaddVarToRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_VAR}, Cdouble), + scip, + row, + var, + val, + ) end function SCIPaddVarsToRow(scip, row, nvars, vars, vals) - ccall((:SCIPaddVarsToRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, row, nvars, vars, vals) + ccall( + (:SCIPaddVarsToRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), + scip, + row, + nvars, + vars, + vals, + ) end function SCIPaddVarsToRowSameCoef(scip, row, nvars, vars, val) - ccall((:SCIPaddVarsToRowSameCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Cdouble), scip, row, nvars, vars, val) -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, Cuint, Ptr{Cdouble}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}), scip, row, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) + 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, + Cuint, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + 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, + Cuint, + Ptr{Cuint}, + ), + scip, + row, + mindelta, + maxdelta, + maxdnom, + maxscale, + usecontvars, + success, + ) end function SCIPmarkRowNotRemovableLocal(scip, row) - ccall((:SCIPmarkRowNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPmarkRowNotRemovableLocal, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowNumIntCols(scip, row) - ccall((:SCIPgetRowNumIntCols, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowNumIntCols, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowNumImpliedIntCols(scip, row) - ccall((:SCIPgetRowNumImpliedIntCols, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowNumImpliedIntCols, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowMinCoef(scip, row) - ccall((:SCIPgetRowMinCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowMinCoef, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowMaxCoef(scip, row) - ccall((:SCIPgetRowMaxCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowMaxCoef, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowMinActivity(scip, row) - ccall((:SCIPgetRowMinActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowMinActivity, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowMaxActivity(scip, row) - ccall((:SCIPgetRowMaxActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowMaxActivity, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPrecalcRowLPActivity(scip, row) - ccall((:SCIPrecalcRowLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPrecalcRowLPActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowLPActivity(scip, row) - ccall((:SCIPgetRowLPActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowLPActivity, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowLPFeasibility(scip, row) - ccall((:SCIPgetRowLPFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowLPFeasibility, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPrecalcRowPseudoActivity(scip, row) - ccall((:SCIPrecalcRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPrecalcRowPseudoActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowPseudoActivity(scip, row) - ccall((:SCIPgetRowPseudoActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowPseudoActivity, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowPseudoFeasibility(scip, row) - ccall((:SCIPgetRowPseudoFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowPseudoFeasibility, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPrecalcRowActivity(scip, row) - ccall((:SCIPrecalcRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPrecalcRowActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowActivity(scip, row) - ccall((:SCIPgetRowActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowActivity, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowFeasibility(scip, row) - ccall((:SCIPgetRowFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowFeasibility, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPgetRowSolActivity(scip, row, sol) - ccall((:SCIPgetRowSolActivity, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) + ccall( + (:SCIPgetRowSolActivity, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), + scip, + row, + sol, + ) end function SCIPgetRowSolFeasibility(scip, row, sol) - ccall((:SCIPgetRowSolFeasibility, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), scip, row, sol) + ccall( + (:SCIPgetRowSolFeasibility, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{SCIP_SOL}), + scip, + row, + sol, + ) end function SCIPgetRowObjParallelism(scip, row) - ccall((:SCIPgetRowObjParallelism, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPgetRowObjParallelism, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPprintRow(scip, row, file) - ccall((:SCIPprintRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{Libc.FILE}), scip, row, file) + ccall( + (:SCIPprintRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Ptr{Libc.FILE}), + scip, + row, + file, + ) end function SCIPstartDive(scip) @@ -6130,47 +14600,120 @@ function SCIPendDive(scip) end function SCIPchgCutoffboundDive(scip, newcutoffbound) - ccall((:SCIPchgCutoffboundDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newcutoffbound) + ccall( + (:SCIPchgCutoffboundDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + newcutoffbound, + ) end function SCIPchgVarObjDive(scip, var, newobj) - ccall((:SCIPchgVarObjDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) + ccall( + (:SCIPchgVarObjDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newobj, + ) end function SCIPchgVarLbDive(scip, var, newbound) - ccall((:SCIPchgVarLbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall( + (:SCIPchgVarLbDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newbound, + ) end function SCIPchgVarUbDive(scip, var, newbound) - ccall((:SCIPchgVarUbDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall( + (:SCIPchgVarUbDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newbound, + ) end function SCIPaddRowDive(scip, row) - ccall((:SCIPaddRowDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPaddRowDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPchgRowLhsDive(scip, row, newlhs) - ccall((:SCIPchgRowLhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newlhs) + ccall( + (:SCIPchgRowLhsDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), + scip, + row, + newlhs, + ) end function SCIPchgRowRhsDive(scip, row, newrhs) - ccall((:SCIPchgRowRhsDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), scip, row, newrhs) + ccall( + (:SCIPchgRowRhsDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble), + scip, + row, + newrhs, + ) end function SCIPgetVarObjDive(scip, var) - ccall((:SCIPgetVarObjDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarObjDive, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarLbDive(scip, var) - ccall((:SCIPgetVarLbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarLbDive, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarUbDive(scip, var) - ccall((:SCIPgetVarUbDive, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarUbDive, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPsolveDiveLP(scip, itlim, lperror, cutoff) - ccall((:SCIPsolveDiveLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, itlim, lperror, cutoff) + ccall( + (:SCIPsolveDiveLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), + scip, + itlim, + lperror, + cutoff, + ) end function SCIPgetLastDivenode(scip) @@ -6182,7 +14725,14 @@ function SCIPinDive(scip) end function SCIPgetLPDualDegeneracy(scip, degeneracy, varconsratio) - ccall((:SCIPgetLPDualDegeneracy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}, Ptr{Cdouble}), scip, degeneracy, varconsratio) + ccall( + (:SCIPgetLPDualDegeneracy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cdouble}, Ptr{Cdouble}), + scip, + degeneracy, + varconsratio, + ) end function SCIPgetMemUsed(scip) @@ -6210,19 +14760,42 @@ function SCIPcollectMemoryGarbage(scip) end function SCIPsetMessagehdlr(scip, messagehdlr) - ccall((:SCIPsetMessagehdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_MESSAGEHDLR}), scip, messagehdlr) + ccall( + (:SCIPsetMessagehdlr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_MESSAGEHDLR}), + scip, + messagehdlr, + ) end function SCIPgetMessagehdlr(scip) - ccall((:SCIPgetMessagehdlr, libscip), Ptr{SCIP_MESSAGEHDLR}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetMessagehdlr, libscip), + Ptr{SCIP_MESSAGEHDLR}, + (Ptr{SCIP},), + scip, + ) end function SCIPsetMessagehdlrLogfile(scip, filename) - ccall((:SCIPsetMessagehdlrLogfile, libscip), Cvoid, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) + ccall( + (:SCIPsetMessagehdlrLogfile, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + filename, + ) end function SCIPsetMessagehdlrQuiet(scip, quiet) - ccall((:SCIPsetMessagehdlrQuiet, libscip), Cvoid, (Ptr{SCIP}, Cuint), scip, quiet) + ccall( + (:SCIPsetMessagehdlrQuiet, libscip), + Cvoid, + (Ptr{SCIP}, Cuint), + scip, + quiet, + ) end function SCIPgetVerbLevel(scip) @@ -6242,11 +14815,24 @@ function SCIPisNLPConstructed(scip) end function SCIPhasNLPContinuousNonlinearity(scip, result) - ccall((:SCIPhasNLPContinuousNonlinearity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, result) + ccall( + (:SCIPhasNLPContinuousNonlinearity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}), + scip, + result, + ) end function SCIPgetNLPVarsData(scip, vars, nvars) - ccall((:SCIPgetNLPVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}), scip, vars, nvars) + ccall( + (:SCIPgetNLPVarsData, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}), + scip, + vars, + nvars, + ) end function SCIPgetNLPVars(scip) @@ -6258,7 +14844,13 @@ function SCIPgetNNLPVars(scip) end function SCIPgetNLPVarsNonlinearity(scip, nlcount) - ccall((:SCIPgetNLPVarsNonlinearity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}), scip, nlcount) + ccall( + (:SCIPgetNLPVarsNonlinearity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cint}), + scip, + nlcount, + ) end function SCIPgetNLPVarsLbDualsol(scip) @@ -6270,27 +14862,66 @@ function SCIPgetNLPVarsUbDualsol(scip) end function SCIPgetNLPNlRowsData(scip, nlrows, nnlrows) - ccall((:SCIPgetNLPNlRowsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NLROW}}}, Ptr{Cint}), scip, nlrows, nnlrows) + ccall( + (:SCIPgetNLPNlRowsData, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NLROW}}}, Ptr{Cint}), + scip, + nlrows, + nnlrows, + ) end function SCIPgetNLPNlRows(scip) - ccall((:SCIPgetNLPNlRows, libscip), Ptr{Ptr{SCIP_NLROW}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNLPNlRows, libscip), + Ptr{Ptr{SCIP_NLROW}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNNLPNlRows(scip) ccall((:SCIPgetNNLPNlRows, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPgetNLPNlRowsStat(scip, nlinear, nconvexineq, nnonconvexineq, nnonlineareq) - ccall((:SCIPgetNLPNlRowsStat, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, nlinear, nconvexineq, nnonconvexineq, nnonlineareq) +function SCIPgetNLPNlRowsStat( + scip, + nlinear, + nconvexineq, + nnonconvexineq, + nnonlineareq, +) + ccall( + (:SCIPgetNLPNlRowsStat, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), + scip, + nlinear, + nconvexineq, + nnonconvexineq, + nnonlineareq, + ) end function SCIPaddNlRow(scip, nlrow) - ccall((:SCIPaddNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall( + (:SCIPaddNlRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}), + scip, + nlrow, + ) end function SCIPdelNlRow(scip, nlrow) - ccall((:SCIPdelNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall( + (:SCIPdelNlRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}), + scip, + nlrow, + ) end function SCIPflushNLP(scip) @@ -6298,11 +14929,23 @@ function SCIPflushNLP(scip) end function SCIPsetNLPInitialGuess(scip, initialguess) - ccall((:SCIPsetNLPInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cdouble}), scip, initialguess) + ccall( + (:SCIPsetNLPInitialGuess, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cdouble}), + scip, + initialguess, + ) end function SCIPsetNLPInitialGuessSol(scip, sol) - ccall((:SCIPsetNLPInitialGuessSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPsetNLPInitialGuessSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPgetNLPSolstat(scip) @@ -6314,7 +14957,13 @@ function SCIPgetNLPTermstat(scip) end function SCIPgetNLPStatistics(scip, statistics) - ccall((:SCIPgetNLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPSTATISTICS}), scip, statistics) + ccall( + (:SCIPgetNLPStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLPSTATISTICS}), + scip, + statistics, + ) end function SCIPgetNLPObjval(scip) @@ -6325,16 +14974,53 @@ function SCIPhasNLPSolution(scip) ccall((:SCIPhasNLPSolution, libscip), Cuint, (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) +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 SCIPwriteNLP(scip, filename) - ccall((:SCIPwriteNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) + ccall( + (:SCIPwriteNLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + filename, + ) end function SCIPgetNLPI(scip, nlpi, nlpiproblem) - ccall((:SCIPgetNLPI, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLPI}}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), scip, nlpi, nlpiproblem) + ccall( + (:SCIPgetNLPI, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_NLPI}}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), + scip, + nlpi, + nlpiproblem, + ) end function SCIPstartDiveNLP(scip) @@ -6346,127 +15032,462 @@ function SCIPendDiveNLP(scip) end function SCIPchgVarObjDiveNLP(scip, var, coef) - ccall((:SCIPchgVarObjDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, coef) + ccall( + (:SCIPchgVarObjDiveNLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + coef, + ) end function SCIPchgVarBoundsDiveNLP(scip, var, lb, ub) - ccall((:SCIPchgVarBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, lb, ub) + ccall( + (:SCIPchgVarBoundsDiveNLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + scip, + var, + lb, + ub, + ) end function SCIPchgVarsBoundsDiveNLP(scip, nvars, vars, lbs, ubs) - ccall((:SCIPchgVarsBoundsDiveNLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nvars, vars, lbs, ubs) -end - -function SCIPcreateNlRow(scip, nlrow, name, constant, nlinvars, linvars, lincoefs, expr, lhs, rhs, curvature) - ccall((:SCIPcreateNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{Cchar}, Cdouble, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_EXPR}, Cdouble, Cdouble, SCIP_EXPRCURV), scip, nlrow, name, constant, nlinvars, linvars, lincoefs, expr, lhs, rhs, curvature) + ccall( + (:SCIPchgVarsBoundsDiveNLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), + scip, + nvars, + vars, + lbs, + ubs, + ) +end + +function SCIPcreateNlRow( + scip, + nlrow, + name, + constant, + nlinvars, + linvars, + lincoefs, + expr, + lhs, + rhs, + curvature, +) + ccall( + (:SCIPcreateNlRow, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_NLROW}}, + Ptr{Cchar}, + Cdouble, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{SCIP_EXPR}, + Cdouble, + Cdouble, + SCIP_EXPRCURV, + ), + scip, + nlrow, + name, + constant, + nlinvars, + linvars, + lincoefs, + expr, + lhs, + rhs, + curvature, + ) end function SCIPcreateEmptyNlRow(scip, nlrow, name, lhs, rhs) - ccall((:SCIPcreateEmptyNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{Cchar}, Cdouble, Cdouble), scip, nlrow, name, lhs, rhs) + ccall( + (:SCIPcreateEmptyNlRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{Cchar}, Cdouble, Cdouble), + scip, + nlrow, + name, + lhs, + rhs, + ) end function SCIPcreateNlRowFromRow(scip, nlrow, row) - ccall((:SCIPcreateNlRowFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{SCIP_ROW}), scip, nlrow, row) + ccall( + (:SCIPcreateNlRowFromRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}, Ptr{SCIP_ROW}), + scip, + nlrow, + row, + ) end function SCIPcaptureNlRow(scip, nlrow) - ccall((:SCIPcaptureNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall( + (:SCIPcaptureNlRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}), + scip, + nlrow, + ) end function SCIPreleaseNlRow(scip, nlrow) - ccall((:SCIPreleaseNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}), scip, nlrow) + ccall( + (:SCIPreleaseNlRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_NLROW}}), + scip, + nlrow, + ) end function SCIPchgNlRowLhs(scip, nlrow, lhs) - ccall((:SCIPchgNlRowLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, lhs) + ccall( + (:SCIPchgNlRowLhs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), + scip, + nlrow, + lhs, + ) end function SCIPchgNlRowRhs(scip, nlrow, rhs) - ccall((:SCIPchgNlRowRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, rhs) + ccall( + (:SCIPchgNlRowRhs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), + scip, + nlrow, + rhs, + ) end function SCIPchgNlRowConstant(scip, nlrow, constant) - ccall((:SCIPchgNlRowConstant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), scip, nlrow, constant) + ccall( + (:SCIPchgNlRowConstant, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cdouble), + scip, + nlrow, + constant, + ) end function SCIPsetNlRowCurvature(scip, nlrow, curvature) - ccall((:SCIPsetNlRowCurvature, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_EXPRCURV), scip, nlrow, curvature) + ccall( + (:SCIPsetNlRowCurvature, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, SCIP_EXPRCURV), + scip, + nlrow, + curvature, + ) end function SCIPaddLinearCoefToNlRow(scip, nlrow, var, val) - ccall((:SCIPaddLinearCoefToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, val) + ccall( + (:SCIPaddLinearCoefToNlRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), + scip, + nlrow, + var, + val, + ) end function SCIPaddLinearCoefsToNlRow(scip, nlrow, nvars, vars, vals) - ccall((:SCIPaddLinearCoefsToNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nlrow, nvars, vars, vals) + ccall( + (:SCIPaddLinearCoefsToNlRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), + scip, + nlrow, + nvars, + vars, + vals, + ) end function SCIPchgNlRowLinearCoef(scip, nlrow, var, coef) - ccall((:SCIPchgNlRowLinearCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), scip, nlrow, var, coef) + ccall( + (:SCIPchgNlRowLinearCoef, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_VAR}, Cdouble), + scip, + nlrow, + var, + coef, + ) end function SCIPsetNlRowExpr(scip, nlrow, expr) - ccall((:SCIPsetNlRowExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_EXPR}), scip, nlrow, expr) + ccall( + (:SCIPsetNlRowExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_EXPR}), + scip, + nlrow, + expr, + ) end function SCIPrecalcNlRowNLPActivity(scip, nlrow) - ccall((:SCIPrecalcNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall( + (:SCIPrecalcNlRowNLPActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}), + scip, + nlrow, + ) end function SCIPgetNlRowNLPActivity(scip, nlrow, activity) - ccall((:SCIPgetNlRowNLPActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) + ccall( + (:SCIPgetNlRowNLPActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), + scip, + nlrow, + activity, + ) end function SCIPgetNlRowNLPFeasibility(scip, nlrow, feasibility) - ccall((:SCIPgetNlRowNLPFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) + ccall( + (:SCIPgetNlRowNLPFeasibility, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), + scip, + nlrow, + feasibility, + ) end function SCIPrecalcNlRowPseudoActivity(scip, nlrow) - ccall((:SCIPrecalcNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall( + (:SCIPrecalcNlRowPseudoActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}), + scip, + nlrow, + ) end function SCIPgetNlRowPseudoActivity(scip, nlrow, pseudoactivity) - ccall((:SCIPgetNlRowPseudoActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudoactivity) + ccall( + (:SCIPgetNlRowPseudoActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), + scip, + nlrow, + pseudoactivity, + ) end function SCIPgetNlRowPseudoFeasibility(scip, nlrow, pseudofeasibility) - ccall((:SCIPgetNlRowPseudoFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, pseudofeasibility) + ccall( + (:SCIPgetNlRowPseudoFeasibility, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), + scip, + nlrow, + pseudofeasibility, + ) end function SCIPrecalcNlRowActivity(scip, nlrow) - ccall((:SCIPrecalcNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}), scip, nlrow) + ccall( + (:SCIPrecalcNlRowActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}), + scip, + nlrow, + ) end function SCIPgetNlRowActivity(scip, nlrow, activity) - ccall((:SCIPgetNlRowActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, activity) + ccall( + (:SCIPgetNlRowActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), + scip, + nlrow, + activity, + ) end function SCIPgetNlRowFeasibility(scip, nlrow, feasibility) - ccall((:SCIPgetNlRowFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), scip, nlrow, feasibility) + ccall( + (:SCIPgetNlRowFeasibility, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}), + scip, + nlrow, + feasibility, + ) end function SCIPgetNlRowSolActivity(scip, nlrow, sol, activity) - ccall((:SCIPgetNlRowSolActivity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, activity) + ccall( + (:SCIPgetNlRowSolActivity, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), + scip, + nlrow, + sol, + activity, + ) end function SCIPgetNlRowSolFeasibility(scip, nlrow, sol, feasibility) - ccall((:SCIPgetNlRowSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, nlrow, sol, feasibility) + ccall( + (:SCIPgetNlRowSolFeasibility, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{SCIP_SOL}, Ptr{Cdouble}), + scip, + nlrow, + sol, + feasibility, + ) end function SCIPgetNlRowActivityBounds(scip, nlrow, minactivity, maxactivity) - ccall((:SCIPgetNlRowActivityBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlrow, minactivity, maxactivity) + ccall( + (:SCIPgetNlRowActivityBounds, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Cdouble}, Ptr{Cdouble}), + scip, + nlrow, + minactivity, + maxactivity, + ) end function SCIPprintNlRow(scip, nlrow, file) - ccall((:SCIPprintNlRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Libc.FILE}), scip, nlrow, file) -end - -function SCIPincludeNlpi(scip, name, description, priority, nlpicopy, nlpifree, nlpigetsolverpointer, nlpicreateproblem, nlpifreeproblem, nlpigetproblempointer, nlpiaddvars, nlpiaddconstraints, nlpisetobjective, nlpichgvarbounds, nlpichgconssides, nlpidelvarset, nlpidelconsset, nlpichglinearcoefs, nlpichgexpr, nlpichgobjconstant, nlpisetinitialguess, nlpisolve, nlpigetsolstat, nlpigettermstat, nlpigetsolution, nlpigetstatistics, nlpidata) - ccall((:SCIPincludeNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, 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_NLPIDATA}), scip, name, description, priority, nlpicopy, nlpifree, nlpigetsolverpointer, nlpicreateproblem, nlpifreeproblem, nlpigetproblempointer, nlpiaddvars, nlpiaddconstraints, nlpisetobjective, nlpichgvarbounds, nlpichgconssides, nlpidelvarset, nlpidelconsset, nlpichglinearcoefs, nlpichgexpr, nlpichgobjconstant, nlpisetinitialguess, nlpisolve, nlpigetsolstat, nlpigettermstat, nlpigetsolution, nlpigetstatistics, nlpidata) + ccall( + (:SCIPprintNlRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLROW}, Ptr{Libc.FILE}), + scip, + nlrow, + file, + ) +end + +function SCIPincludeNlpi( + scip, + name, + description, + priority, + nlpicopy, + nlpifree, + nlpigetsolverpointer, + nlpicreateproblem, + nlpifreeproblem, + nlpigetproblempointer, + nlpiaddvars, + nlpiaddconstraints, + nlpisetobjective, + nlpichgvarbounds, + nlpichgconssides, + nlpidelvarset, + nlpidelconsset, + nlpichglinearcoefs, + nlpichgexpr, + nlpichgobjconstant, + nlpisetinitialguess, + nlpisolve, + nlpigetsolstat, + nlpigettermstat, + nlpigetsolution, + nlpigetstatistics, + nlpidata, +) + ccall( + (:SCIPincludeNlpi, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + 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_NLPIDATA}, + ), + scip, + name, + description, + priority, + nlpicopy, + nlpifree, + nlpigetsolverpointer, + nlpicreateproblem, + nlpifreeproblem, + nlpigetproblempointer, + nlpiaddvars, + nlpiaddconstraints, + nlpisetobjective, + nlpichgvarbounds, + nlpichgconssides, + nlpidelvarset, + nlpidelconsset, + nlpichglinearcoefs, + nlpichgexpr, + nlpichgobjconstant, + nlpisetinitialguess, + nlpisolve, + nlpigetsolstat, + nlpigettermstat, + nlpigetsolution, + nlpigetstatistics, + nlpidata, + ) end function SCIPfindNlpi(scip, name) - ccall((:SCIPfindNlpi, libscip), Ptr{SCIP_NLPI}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindNlpi, libscip), + Ptr{SCIP_NLPI}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetNlpis(scip) @@ -6478,139 +15499,689 @@ function SCIPgetNNlpis(scip) end function SCIPsetNlpiPriority(scip, nlpi, priority) - ccall((:SCIPsetNlpiPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Cint), scip, nlpi, priority) + ccall( + (:SCIPsetNlpiPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Cint), + scip, + nlpi, + priority, + ) end function SCIPgetNlpiSolverPointer(scip, nlpi, problem) - ccall((:SCIPgetNlpiSolverPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), scip, nlpi, problem) + ccall( + (:SCIPgetNlpiSolverPointer, libscip), + Ptr{Cvoid}, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), + scip, + nlpi, + problem, + ) end function SCIPcreateNlpiProblem(scip, nlpi, problem, name) - ccall((:SCIPcreateNlpiProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}), scip, nlpi, problem, name) + ccall( + (:SCIPcreateNlpiProblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}), + scip, + nlpi, + problem, + name, + ) end function SCIPfreeNlpiProblem(scip, nlpi, problem) - ccall((:SCIPfreeNlpiProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), scip, nlpi, problem) + ccall( + (:SCIPfreeNlpiProblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}), + scip, + nlpi, + problem, + ) end function SCIPgetNlpiProblemPointer(scip, nlpi, problem) - ccall((:SCIPgetNlpiProblemPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), scip, nlpi, problem) + ccall( + (:SCIPgetNlpiProblemPointer, libscip), + Ptr{Cvoid}, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), + scip, + nlpi, + problem, + ) end function SCIPaddNlpiVars(scip, nlpi, problem, nvars, lbs, ubs, varnames) - ccall((:SCIPaddNlpiVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), scip, nlpi, problem, nvars, lbs, ubs, varnames) -end - -function SCIPaddNlpiConstraints(scip, nlpi, problem, nconss, lhss, rhss, nlininds, lininds, linvals, exprs, names) - ccall((:SCIPaddNlpiConstraints, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Ptr{Cchar}}), scip, nlpi, problem, nconss, lhss, rhss, nlininds, lininds, linvals, exprs, names) -end - -function SCIPsetNlpiObjective(scip, nlpi, problem, nlins, lininds, linvals, expr, constant) - ccall((:SCIPsetNlpiObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_EXPR}, Cdouble), scip, nlpi, problem, nlins, lininds, linvals, expr, constant) + ccall( + (:SCIPaddNlpiVars, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Ptr{Cchar}}, + ), + scip, + nlpi, + problem, + nvars, + lbs, + ubs, + varnames, + ) +end + +function SCIPaddNlpiConstraints( + scip, + nlpi, + problem, + nconss, + lhss, + rhss, + nlininds, + lininds, + linvals, + exprs, + names, +) + ccall( + (:SCIPaddNlpiConstraints, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Ptr{Cchar}}, + ), + scip, + nlpi, + problem, + nconss, + lhss, + rhss, + nlininds, + lininds, + linvals, + exprs, + names, + ) +end + +function SCIPsetNlpiObjective( + scip, + nlpi, + problem, + nlins, + lininds, + linvals, + expr, + constant, +) + ccall( + (:SCIPsetNlpiObjective, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{SCIP_EXPR}, + Cdouble, + ), + scip, + nlpi, + problem, + nlins, + lininds, + linvals, + expr, + constant, + ) end function SCIPchgNlpiVarBounds(scip, nlpi, problem, nvars, indices, lbs, ubs) - ccall((:SCIPchgNlpiVarBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlpi, problem, nvars, indices, lbs, ubs) + ccall( + (:SCIPchgNlpiVarBounds, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + scip, + nlpi, + problem, + nvars, + indices, + lbs, + ubs, + ) end function SCIPchgNlpiConsSides(scip, nlpi, problem, nconss, indices, lhss, rhss) - ccall((:SCIPchgNlpiConsSides, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlpi, problem, nconss, indices, lhss, rhss) + ccall( + (:SCIPchgNlpiConsSides, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + scip, + nlpi, + problem, + nconss, + indices, + lhss, + rhss, + ) end function SCIPdelNlpiVarSet(scip, nlpi, problem, dstats, dstatssize) - ccall((:SCIPdelNlpiVarSet, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), scip, nlpi, problem, dstats, dstatssize) + ccall( + (:SCIPdelNlpiVarSet, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), + scip, + nlpi, + problem, + dstats, + dstatssize, + ) end function SCIPdelNlpiConsSet(scip, nlpi, problem, dstats, dstatssize) - ccall((:SCIPdelNlpiConsSet, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), scip, nlpi, problem, dstats, dstatssize) + ccall( + (:SCIPdelNlpiConsSet, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cint}, Cint), + scip, + nlpi, + problem, + dstats, + dstatssize, + ) end function SCIPchgNlpiLinearCoefs(scip, nlpi, problem, idx, nvals, varidxs, vals) - ccall((:SCIPchgNlpiLinearCoefs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Cint, Ptr{Cint}, Ptr{Cdouble}), scip, nlpi, problem, idx, nvals, varidxs, vals) + ccall( + (:SCIPchgNlpiLinearCoefs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + ), + scip, + nlpi, + problem, + idx, + nvals, + varidxs, + vals, + ) end function SCIPchgNlpiExpr(scip, nlpi, problem, idxcons, expr) - ccall((:SCIPchgNlpiExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cint, Ptr{SCIP_EXPR}), scip, nlpi, problem, idxcons, expr) + ccall( + (:SCIPchgNlpiExpr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Cint, + Ptr{SCIP_EXPR}, + ), + scip, + nlpi, + problem, + idxcons, + expr, + ) end function SCIPchgNlpiObjConstant(scip, nlpi, problem, objconstant) - ccall((:SCIPchgNlpiObjConstant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cdouble), scip, nlpi, problem, objconstant) + ccall( + (:SCIPchgNlpiObjConstant, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Cdouble), + scip, + nlpi, + problem, + objconstant, + ) +end + +function SCIPsetNlpiInitialGuess( + scip, + nlpi, + problem, + primalvalues, + consdualvalues, + varlbdualvalues, + varubdualvalues, +) + ccall( + (:SCIPsetNlpiInitialGuess, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + scip, + nlpi, + problem, + primalvalues, + consdualvalues, + varlbdualvalues, + varubdualvalues, + ) end -function SCIPsetNlpiInitialGuess(scip, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues) - ccall((:SCIPsetNlpiInitialGuess, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), scip, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues) -end - -function SCIPgetNlpiSolstat(scip, nlpi, problem) - ccall((:SCIPgetNlpiSolstat, libscip), SCIP_NLPSOLSTAT, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), scip, nlpi, problem) +function SCIPgetNlpiSolstat(scip, nlpi, problem) + ccall( + (:SCIPgetNlpiSolstat, libscip), + SCIP_NLPSOLSTAT, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), + scip, + nlpi, + problem, + ) end function SCIPgetNlpiTermstat(scip, nlpi, problem) - ccall((:SCIPgetNlpiTermstat, libscip), SCIP_NLPTERMSTAT, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), scip, nlpi, problem) -end - -function SCIPgetNlpiSolution(scip, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) - ccall((:SCIPgetNlpiSolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}), scip, nlpi, problem, primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) + ccall( + (:SCIPgetNlpiTermstat, libscip), + SCIP_NLPTERMSTAT, + (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}), + scip, + nlpi, + problem, + ) +end + +function SCIPgetNlpiSolution( + scip, + nlpi, + problem, + primalvalues, + consdualvalues, + varlbdualvalues, + varubdualvalues, + objval, +) + ccall( + (:SCIPgetNlpiSolution, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + Ptr{Cdouble}, + ), + scip, + nlpi, + problem, + primalvalues, + consdualvalues, + varlbdualvalues, + varubdualvalues, + objval, + ) end function SCIPgetNlpiStatistics(scip, nlpi, problem, statistics) - ccall((:SCIPgetNlpiStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_NLPSTATISTICS}), scip, nlpi, problem, statistics) -end - -function SCIPcreateNlpiProblemFromNlRows(scip, nlpi, nlpiprob, name, nlrows, nnlrows, var2idx, nlrow2idx, nlscore, cutoffbound, setobj, onlyconvex) - ccall((:SCIPcreateNlpiProblemFromNlRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{Ptr{SCIP_NLPIPROBLEM}}, Ptr{Cchar}, Ptr{Ptr{SCIP_NLROW}}, Cint, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Ptr{Cdouble}, Cdouble, Cuint, Cuint), scip, nlpi, nlpiprob, name, nlrows, nnlrows, var2idx, nlrow2idx, nlscore, cutoffbound, setobj, onlyconvex) -end - -function SCIPupdateNlpiProblem(scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) - ccall((:SCIPupdateNlpiProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cdouble), scip, nlpi, nlpiprob, var2nlpiidx, nlpivars, nlpinvars, cutoffbound) + ccall( + (:SCIPgetNlpiStatistics, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Ptr{SCIP_NLPSTATISTICS}, + ), + scip, + nlpi, + problem, + statistics, + ) +end + +function SCIPcreateNlpiProblemFromNlRows( + scip, + nlpi, + nlpiprob, + name, + nlrows, + nnlrows, + var2idx, + nlrow2idx, + nlscore, + cutoffbound, + setobj, + onlyconvex, +) + ccall( + (:SCIPcreateNlpiProblemFromNlRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{Ptr{SCIP_NLPIPROBLEM}}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_NLROW}}, + Cint, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Ptr{Cdouble}, + Cdouble, + Cuint, + Cuint, + ), + scip, + nlpi, + nlpiprob, + name, + nlrows, + nnlrows, + var2idx, + nlrow2idx, + nlscore, + cutoffbound, + setobj, + onlyconvex, + ) +end + +function SCIPupdateNlpiProblem( + scip, + nlpi, + nlpiprob, + var2nlpiidx, + nlpivars, + nlpinvars, + cutoffbound, +) + ccall( + (:SCIPupdateNlpiProblem, 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 SCIPaddNlpiProblemRows(scip, nlpi, nlpiprob, var2idx, rows, nrows) - ccall((:SCIPaddNlpiProblemRows, 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 - -function SCIPaddNlpiProblemNlRows(scip, nlpi, nlpiprob, var2idx, nlrows, nnlrows) - ccall((:SCIPaddNlpiProblemNlRows, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLPI}, Ptr{SCIP_NLPIPROBLEM}, Ptr{SCIP_HASHMAP}, Ptr{Ptr{SCIP_NLROW}}, Cint), scip, nlpi, nlpiprob, var2idx, nlrows, nnlrows) -end - -function SCIPincludeNodesel(scip, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) - ccall((:SCIPincludeNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), scip, nodesel, name, desc, stdpriority, memsavepriority, nodeselselect, nodeselcomp, nodeseldata) + ccall( + (:SCIPaddNlpiProblemRows, 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 + +function SCIPaddNlpiProblemNlRows( + scip, + nlpi, + nlpiprob, + var2idx, + nlrows, + nnlrows, +) + ccall( + (:SCIPaddNlpiProblemNlRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLPI}, + Ptr{SCIP_NLPIPROBLEM}, + Ptr{SCIP_HASHMAP}, + Ptr{Ptr{SCIP_NLROW}}, + Cint, + ), + scip, + nlpi, + nlpiprob, + var2idx, + nlrows, + nnlrows, + ) +end + +function SCIPincludeNodesel( + scip, + name, + desc, + stdpriority, + memsavepriority, + nodeselcopy, + nodeselfree, + nodeselinit, + nodeselexit, + nodeselinitsol, + nodeselexitsol, + nodeselselect, + nodeselcomp, + nodeseldata, +) + ccall( + (:SCIPincludeNodesel, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_NODESELDATA}, + ), + scip, + nodesel, + name, + desc, + stdpriority, + memsavepriority, + nodeselselect, + nodeselcomp, + nodeseldata, + ) end function SCIPsetNodeselCopy(scip, nodesel, nodeselcopy) - ccall((:SCIPsetNodeselCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselcopy) + ccall( + (:SCIPsetNodeselCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + scip, + nodesel, + nodeselcopy, + ) end function SCIPsetNodeselFree(scip, nodesel, nodeselfree) - ccall((:SCIPsetNodeselFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselfree) + ccall( + (:SCIPsetNodeselFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + scip, + nodesel, + nodeselfree, + ) end function SCIPsetNodeselInit(scip, nodesel, nodeselinit) - ccall((:SCIPsetNodeselInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinit) + ccall( + (:SCIPsetNodeselInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + scip, + nodesel, + nodeselinit, + ) end function SCIPsetNodeselExit(scip, nodesel, nodeselexit) - ccall((:SCIPsetNodeselExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexit) + ccall( + (:SCIPsetNodeselExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + scip, + nodesel, + nodeselexit, + ) end function SCIPsetNodeselInitsol(scip, nodesel, nodeselinitsol) - ccall((:SCIPsetNodeselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselinitsol) + ccall( + (:SCIPsetNodeselInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + scip, + nodesel, + nodeselinitsol, + ) end function SCIPsetNodeselExitsol(scip, nodesel, nodeselexitsol) - ccall((:SCIPsetNodeselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), scip, nodesel, nodeselexitsol) + ccall( + (:SCIPsetNodeselExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + scip, + nodesel, + nodeselexitsol, + ) end function SCIPfindNodesel(scip, name) - ccall((:SCIPfindNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindNodesel, libscip), + Ptr{SCIP_NODESEL}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetNodesels(scip) - ccall((:SCIPgetNodesels, libscip), Ptr{Ptr{SCIP_NODESEL}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNodesels, libscip), + Ptr{Ptr{SCIP_NODESEL}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNNodesels(scip) @@ -6618,11 +16189,25 @@ function SCIPgetNNodesels(scip) end function SCIPsetNodeselStdPriority(scip, nodesel, priority) - ccall((:SCIPsetNodeselStdPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) + ccall( + (:SCIPsetNodeselStdPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), + scip, + nodesel, + priority, + ) end function SCIPsetNodeselMemsavePriority(scip, nodesel, priority) - ccall((:SCIPsetNodeselMemsavePriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), scip, nodesel, priority) + ccall( + (:SCIPsetNodeselMemsavePriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODESEL}, Cint), + scip, + nodesel, + priority, + ) end function SCIPgetNodesel(scip) @@ -6650,19 +16235,43 @@ function SCIPrelaxfeastol(scip) end function SCIPchgFeastol(scip, feastol) - ccall((:SCIPchgFeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, feastol) + ccall( + (:SCIPchgFeastol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + feastol, + ) end function SCIPchgDualfeastol(scip, dualfeastol) - ccall((:SCIPchgDualfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, dualfeastol) + ccall( + (:SCIPchgDualfeastol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + dualfeastol, + ) end function SCIPchgBarrierconvtol(scip, barrierconvtol) - ccall((:SCIPchgBarrierconvtol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, barrierconvtol) + ccall( + (:SCIPchgBarrierconvtol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + barrierconvtol, + ) end function SCIPchgRelaxfeastol(scip, relaxfeastol) - ccall((:SCIPchgRelaxfeastol, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, relaxfeastol) + ccall( + (:SCIPchgRelaxfeastol, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + relaxfeastol, + ) end function SCIPmarkLimitChanged(scip) @@ -6678,23 +16287,58 @@ function SCIPgetHugeValue(scip) end function SCIPisEQ(scip, val1, val2) - ccall((:SCIPisEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisEQ, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisLT(scip, val1, val2) - ccall((:SCIPisLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisLT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisLE(scip, val1, val2) - ccall((:SCIPisLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisLE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisGT(scip, val1, val2) - ccall((:SCIPisGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisGT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisGE(scip, val1, val2) - ccall((:SCIPisGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisGE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisInfinity(scip, val) @@ -6722,11 +16366,24 @@ function SCIPisIntegral(scip, val) end function SCIPisScalingIntegral(scip, val, scalar) - ccall((:SCIPisScalingIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val, scalar) + ccall( + (:SCIPisScalingIntegral, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val, + scalar, + ) end function SCIPisFracIntegral(scip, val) - ccall((:SCIPisFracIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisFracIntegral, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPfloor(scip, val) @@ -6746,23 +16403,58 @@ function SCIPfrac(scip, val) end function SCIPisSumEQ(scip, val1, val2) - ccall((:SCIPisSumEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumEQ, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumLT(scip, val1, val2) - ccall((:SCIPisSumLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumLT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumLE(scip, val1, val2) - ccall((:SCIPisSumLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumLE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumGT(scip, val1, val2) - ccall((:SCIPisSumGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumGT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumGE(scip, val1, val2) - ccall((:SCIPisSumGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumGE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumZero(scip, val) @@ -6778,23 +16470,58 @@ function SCIPisSumNegative(scip, val) end function SCIPisFeasEQ(scip, val1, val2) - ccall((:SCIPisFeasEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisFeasEQ, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisFeasLT(scip, val1, val2) - ccall((:SCIPisFeasLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisFeasLT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisFeasLE(scip, val1, val2) - ccall((:SCIPisFeasLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisFeasLE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisFeasGT(scip, val1, val2) - ccall((:SCIPisFeasGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisFeasGT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisFeasGE(scip, val1, val2) - ccall((:SCIPisFeasGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisFeasGE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisFeasZero(scip, val) @@ -6802,19 +16529,43 @@ function SCIPisFeasZero(scip, val) end function SCIPisFeasPositive(scip, val) - ccall((:SCIPisFeasPositive, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisFeasPositive, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPisFeasNegative(scip, val) - ccall((:SCIPisFeasNegative, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisFeasNegative, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPisFeasIntegral(scip, val) - ccall((:SCIPisFeasIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisFeasIntegral, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPisFeasFracIntegral(scip, val) - ccall((:SCIPisFeasFracIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisFeasFracIntegral, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPfeasFloor(scip, val) @@ -6834,287 +16585,935 @@ function SCIPfeasFrac(scip, val) end function SCIPisDualfeasEQ(scip, val1, val2) - ccall((:SCIPisDualfeasEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisDualfeasEQ, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisDualfeasLT(scip, val1, val2) - ccall((:SCIPisDualfeasLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisDualfeasLT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisDualfeasLE(scip, val1, val2) - ccall((:SCIPisDualfeasLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisDualfeasLE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisDualfeasGT(scip, val1, val2) - ccall((:SCIPisDualfeasGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisDualfeasGT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisDualfeasGE(scip, val1, val2) - ccall((:SCIPisDualfeasGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisDualfeasGE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisDualfeasZero(scip, val) - ccall((:SCIPisDualfeasZero, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisDualfeasZero, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPisDualfeasPositive(scip, val) - ccall((:SCIPisDualfeasPositive, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisDualfeasPositive, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPisDualfeasNegative(scip, val) - ccall((:SCIPisDualfeasNegative, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisDualfeasNegative, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPisDualfeasIntegral(scip, val) - ccall((:SCIPisDualfeasIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisDualfeasIntegral, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPisDualfeasFracIntegral(scip, val) - ccall((:SCIPisDualfeasFracIntegral, libscip), Cuint, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPisDualfeasFracIntegral, libscip), + Cuint, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPdualfeasFloor(scip, val) - ccall((:SCIPdualfeasFloor, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPdualfeasFloor, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPdualfeasCeil(scip, val) - ccall((:SCIPdualfeasCeil, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPdualfeasCeil, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPdualfeasRound(scip, val) - ccall((:SCIPdualfeasRound, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPdualfeasRound, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPdualfeasFrac(scip, val) - ccall((:SCIPdualfeasFrac, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, val) + ccall( + (:SCIPdualfeasFrac, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + val, + ) end function SCIPisLbBetter(scip, newlb, oldlb, oldub) - ccall((:SCIPisLbBetter, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newlb, oldlb, oldub) + ccall( + (:SCIPisLbBetter, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), + scip, + newlb, + oldlb, + oldub, + ) end function SCIPisUbBetter(scip, newub, oldlb, oldub) - ccall((:SCIPisUbBetter, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, newub, oldlb, oldub) + ccall( + (:SCIPisUbBetter, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), + scip, + newub, + oldlb, + oldub, + ) end function SCIPisRelEQ(scip, val1, val2) - ccall((:SCIPisRelEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisRelEQ, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisRelLT(scip, val1, val2) - ccall((:SCIPisRelLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisRelLT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisRelLE(scip, val1, val2) - ccall((:SCIPisRelLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisRelLE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisRelGT(scip, val1, val2) - ccall((:SCIPisRelGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisRelGT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisRelGE(scip, val1, val2) - ccall((:SCIPisRelGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisRelGE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumRelEQ(scip, val1, val2) - ccall((:SCIPisSumRelEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumRelEQ, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumRelLT(scip, val1, val2) - ccall((:SCIPisSumRelLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumRelLT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumRelLE(scip, val1, val2) - ccall((:SCIPisSumRelLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumRelLE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumRelGT(scip, val1, val2) - ccall((:SCIPisSumRelGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumRelGT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPisSumRelGE(scip, val1, val2) - ccall((:SCIPisSumRelGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPisSumRelGE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPconvertRealToInt(scip, real) - ccall((:SCIPconvertRealToInt, libscip), Cint, (Ptr{SCIP}, Cdouble), scip, real) + ccall( + (:SCIPconvertRealToInt, libscip), + Cint, + (Ptr{SCIP}, Cdouble), + scip, + real, + ) end function SCIPconvertRealToLongint(scip, real) - ccall((:SCIPconvertRealToLongint, libscip), Clonglong, (Ptr{SCIP}, Cdouble), scip, real) + ccall( + (:SCIPconvertRealToLongint, libscip), + Clonglong, + (Ptr{SCIP}, Cdouble), + scip, + real, + ) end function SCIPisUpdateUnreliable(scip, newvalue, oldvalue) - ccall((:SCIPisUpdateUnreliable, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, newvalue, oldvalue) + ccall( + (:SCIPisUpdateUnreliable, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + newvalue, + oldvalue, + ) end function SCIPprintReal(scip, file, val, width, precision) - ccall((:SCIPprintReal, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}, Cdouble, Cint, Cint), scip, file, val, width, precision) + ccall( + (:SCIPprintReal, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}, Cdouble, Cint, Cint), + scip, + file, + val, + width, + precision, + ) end function SCIPparseReal(scip, str, value, endptr) - ccall((:SCIPparseReal, libscip), Cuint, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), scip, str, value, endptr) + ccall( + (:SCIPparseReal, libscip), + Cuint, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), + scip, + str, + value, + endptr, + ) end function SCIPparseRational(scip, str, value, endptr) - ccall((:SCIPparseRational, libscip), Cuint, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{Cchar}}), scip, str, value, endptr) -end - -function SCIPaddBoolParam(scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) - ccall((:SCIPaddBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cuint}, Cuint, Cuint, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cint}, Cuint, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Clonglong}, Cuint, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cdouble}, Cuint, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Cchar, Ptr{Cchar}, 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}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Cuint, Ptr{Cchar}, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), scip, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) + ccall( + (:SCIPparseRational, libscip), + Cuint, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{Cchar}}), + scip, + str, + value, + endptr, + ) +end + +function SCIPaddBoolParam( + scip, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + paramchgd, + paramdata, +) + ccall( + (:SCIPaddBoolParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cuint}, + Cuint, + Cuint, + 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}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cint}, + Cuint, + 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}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Clonglong}, + Cuint, + 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}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cdouble}, + Cuint, + 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}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cchar}, + Cuint, + Cchar, + Ptr{Cchar}, + 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}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Ptr{Cchar}}, + Cuint, + Ptr{Cchar}, + Ptr{Cvoid}, + Ptr{SCIP_PARAMDATA}, + ), + scip, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + paramchgd, + paramdata, + ) end function SCIPisParamFixed(scip, name) - ccall((:SCIPisParamFixed, libscip), Cuint, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPisParamFixed, libscip), + Cuint, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetParam(scip, name) - ccall((:SCIPgetParam, libscip), Ptr{SCIP_PARAM}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPgetParam, libscip), + Ptr{SCIP_PARAM}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetBoolParam(scip, name, value) - ccall((:SCIPgetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cuint}), scip, name, value) + ccall( + (:SCIPgetBoolParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cuint}), + scip, + name, + value, + ) end function SCIPgetIntParam(scip, name, value) - ccall((:SCIPgetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), scip, name, value) + ccall( + (:SCIPgetIntParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), + scip, + name, + value, + ) end function SCIPgetLongintParam(scip, name, value) - ccall((:SCIPgetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Clonglong}), scip, name, value) + ccall( + (:SCIPgetLongintParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Clonglong}), + scip, + name, + value, + ) end function SCIPgetRealParam(scip, name, value) - ccall((:SCIPgetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cdouble}), scip, name, value) + ccall( + (:SCIPgetRealParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cdouble}), + scip, + name, + value, + ) end function SCIPgetCharParam(scip, name, value) - ccall((:SCIPgetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, name, value) + ccall( + (:SCIPgetCharParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), + scip, + name, + value, + ) end function SCIPgetStringParam(scip, name, value) - ccall((:SCIPgetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), scip, name, value) + ccall( + (:SCIPgetStringParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), + scip, + name, + value, + ) end function SCIPfixParam(scip, name) - ccall((:SCIPfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfixParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPunfixParam(scip, name) - ccall((:SCIPunfixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPunfixParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPchgBoolParam(scip, param, value) - ccall((:SCIPchgBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cuint), scip, param, value) + ccall( + (:SCIPchgBoolParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cuint), + scip, + param, + value, + ) end function SCIPsetBoolParam(scip, name, value) - ccall((:SCIPsetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cuint), scip, name, value) + ccall( + (:SCIPsetBoolParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Cuint), + scip, + name, + value, + ) end function SCIPisBoolParamValid(scip, param, value) - ccall((:SCIPisBoolParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cuint), scip, param, value) + ccall( + (:SCIPisBoolParamValid, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cuint), + scip, + param, + value, + ) end function SCIPchgIntParam(scip, param, value) - ccall((:SCIPchgIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) + ccall( + (:SCIPchgIntParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), + scip, + param, + value, + ) end function SCIPsetIntParam(scip, name, value) - ccall((:SCIPsetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cint), scip, name, value) + ccall( + (:SCIPsetIntParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Cint), + scip, + name, + value, + ) end function SCIPisIntParamValid(scip, param, value) - ccall((:SCIPisIntParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), scip, param, value) + ccall( + (:SCIPisIntParamValid, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cint), + scip, + param, + value, + ) end function SCIPchgLongintParam(scip, param, value) - ccall((:SCIPchgLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) + ccall( + (:SCIPchgLongintParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), + scip, + param, + value, + ) end function SCIPsetLongintParam(scip, name, value) - ccall((:SCIPsetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Clonglong), scip, name, value) + ccall( + (:SCIPsetLongintParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Clonglong), + scip, + name, + value, + ) end function SCIPisLongintParamValid(scip, param, value) - ccall((:SCIPisLongintParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), scip, param, value) + ccall( + (:SCIPisLongintParamValid, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Clonglong), + scip, + param, + value, + ) end function SCIPchgRealParam(scip, param, value) - ccall((:SCIPchgRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) + ccall( + (:SCIPchgRealParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), + scip, + param, + value, + ) end function SCIPsetRealParam(scip, name, value) - ccall((:SCIPsetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cdouble), scip, name, value) + ccall( + (:SCIPsetRealParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Cdouble), + scip, + name, + value, + ) end function SCIPisRealParamValid(scip, param, value) - ccall((:SCIPisRealParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cdouble), scip, param, value) + ccall( + (:SCIPisRealParamValid, libscip), + Cuint, + (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}, Cchar), scip, param, value) + ccall( + (:SCIPchgCharParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cchar), + scip, + param, + value, + ) end function SCIPsetCharParam(scip, name, value) - ccall((:SCIPsetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cchar), scip, name, value) + ccall( + (:SCIPsetCharParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Cchar), + scip, + name, + value, + ) end function SCIPisCharParamValid(scip, param, value) - ccall((:SCIPisCharParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cchar), scip, param, value) + ccall( + (:SCIPisCharParamValid, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Cchar), + scip, + param, + value, + ) end function SCIPchgStringParam(scip, param, value) - ccall((:SCIPchgStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}), scip, param, value) + ccall( + (:SCIPchgStringParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}), + scip, + param, + value, + ) end function SCIPsetStringParam(scip, name, value) - ccall((:SCIPsetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, name, value) + ccall( + (:SCIPsetStringParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), + scip, + name, + value, + ) end function SCIPisStringParamValid(scip, param, value) - ccall((:SCIPisStringParamValid, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}), scip, param, value) + ccall( + (:SCIPisStringParamValid, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}), + scip, + param, + value, + ) end function SCIPsetParam(scip, name, value) - ccall((:SCIPsetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, name, value) + ccall( + (:SCIPsetParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), + scip, + name, + value, + ) end function SCIPreadParams(scip, filename) - ccall((:SCIPreadParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) + ccall( + (:SCIPreadParams, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + filename, + ) end function SCIPwriteParam(scip, param, filename, comments, onlychanged) - ccall((:SCIPwriteParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}, Cuint, Cuint), scip, param, filename, comments, onlychanged) + ccall( + (:SCIPwriteParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PARAM}, Ptr{Cchar}, Cuint, Cuint), + scip, + param, + filename, + comments, + onlychanged, + ) end function SCIPwriteParams(scip, filename, comments, onlychanged) - ccall((:SCIPwriteParams, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cuint, Cuint), scip, filename, comments, onlychanged) + ccall( + (:SCIPwriteParams, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Cuint, Cuint), + scip, + filename, + comments, + onlychanged, + ) end function SCIPresetParam(scip, name) - ccall((:SCIPresetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPresetParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPresetParams(scip) @@ -7122,23 +17521,57 @@ function SCIPresetParams(scip) end function SCIPsetEmphasis(scip, paramemphasis, quiet) - ccall((:SCIPsetEmphasis, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMEMPHASIS, Cuint), scip, paramemphasis, quiet) + ccall( + (:SCIPsetEmphasis, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, SCIP_PARAMEMPHASIS, Cuint), + scip, + paramemphasis, + quiet, + ) end function SCIPsetSubscipsOff(scip, quiet) - ccall((:SCIPsetSubscipsOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, quiet) + ccall( + (:SCIPsetSubscipsOff, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint), + scip, + quiet, + ) end function SCIPsetHeuristics(scip, paramsetting, quiet) - ccall((:SCIPsetHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), scip, paramsetting, quiet) + ccall( + (:SCIPsetHeuristics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), + scip, + paramsetting, + quiet, + ) end function SCIPsetPresolving(scip, paramsetting, quiet) - ccall((:SCIPsetPresolving, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), scip, paramsetting, quiet) + ccall( + (:SCIPsetPresolving, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), + scip, + paramsetting, + quiet, + ) end function SCIPsetSeparating(scip, paramsetting, quiet) - ccall((:SCIPsetSeparating, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), scip, paramsetting, quiet) + ccall( + (:SCIPsetSeparating, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, SCIP_PARAMSETTING, Cuint), + scip, + paramsetting, + quiet, + ) end function SCIPgetParams(scip) @@ -7153,40 +17586,169 @@ function SCIPgetSubscipsOff(scip) ccall((:SCIPgetSubscipsOff, libscip), Cuint, (Ptr{SCIP},), scip) end -function SCIPincludePresol(scip, name, desc, priority, maxrounds, timing, presolcopy, presolfree, presolinit, presolexit, presolinitpre, presolexitpre, presolexec, presoldata) - ccall((:SCIPincludePresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, SCIP_PRESOLTIMING, Ptr{Cvoid}, Ptr{SCIP_PRESOLDATA}), scip, presolptr, name, desc, priority, maxrounds, timing, presolexec, presoldata) +function SCIPincludePresol( + scip, + name, + desc, + priority, + maxrounds, + timing, + presolcopy, + presolfree, + presolinit, + presolexit, + presolinitpre, + presolexitpre, + presolexec, + presoldata, +) + ccall( + (:SCIPincludePresol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + SCIP_PRESOLTIMING, + Ptr{Cvoid}, + Ptr{SCIP_PRESOLDATA}, + ), + scip, + presolptr, + name, + desc, + priority, + maxrounds, + timing, + presolexec, + presoldata, + ) end function SCIPsetPresolCopy(scip, presol, presolcopy) - ccall((:SCIPsetPresolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolcopy) + ccall( + (:SCIPsetPresolCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), + scip, + presol, + presolcopy, + ) end function SCIPsetPresolFree(scip, presol, presolfree) - ccall((:SCIPsetPresolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolfree) + ccall( + (:SCIPsetPresolFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), + scip, + presol, + presolfree, + ) end function SCIPsetPresolInit(scip, presol, presolinit) - ccall((:SCIPsetPresolInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinit) + ccall( + (:SCIPsetPresolInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), + scip, + presol, + presolinit, + ) end function SCIPsetPresolExit(scip, presol, presolexit) - ccall((:SCIPsetPresolExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexit) + ccall( + (:SCIPsetPresolExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), + scip, + presol, + presolexit, + ) end function SCIPsetPresolInitpre(scip, presol, presolinitpre) - ccall((:SCIPsetPresolInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolinitpre) + ccall( + (:SCIPsetPresolInitpre, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), + scip, + presol, + presolinitpre, + ) end function SCIPsetPresolExitpre(scip, presol, presolexitpre) - ccall((:SCIPsetPresolExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), scip, presol, presolexitpre) + ccall( + (:SCIPsetPresolExitpre, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Ptr{Cvoid}), + scip, + presol, + presolexitpre, + ) end function SCIPfindPresol(scip, name) - ccall((:SCIPfindPresol, libscip), Ptr{SCIP_PRESOL}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindPresol, libscip), + Ptr{SCIP_PRESOL}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetPresols(scip) @@ -7198,47 +17760,183 @@ function SCIPgetNPresols(scip) end function SCIPsetPresolPriority(scip, presol, priority) - ccall((:SCIPsetPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Cint), scip, presol, priority) + ccall( + (:SCIPsetPresolPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRESOL}, Cint), + scip, + presol, + priority, + ) end function SCIPgetNPresolRounds(scip) ccall((:SCIPgetNPresolRounds, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPincludePricer(scip, name, desc, priority, delay, pricercopy, pricerfree, pricerinit, pricerexit, pricerinitsol, pricerexitsol, pricerredcost, pricerfarkas, pricerdata) - ccall((:SCIPincludePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PRICERDATA}), scip, pricerptr, name, desc, priority, delay, pricerredcost, pricerfarkas, pricerdata) +function SCIPincludePricer( + scip, + name, + desc, + priority, + delay, + pricercopy, + pricerfree, + pricerinit, + pricerexit, + pricerinitsol, + pricerexitsol, + pricerredcost, + pricerfarkas, + pricerdata, +) + ccall( + (:SCIPincludePricer, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cuint, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_PRICERDATA}, + ), + scip, + pricerptr, + name, + desc, + priority, + delay, + pricerredcost, + pricerfarkas, + pricerdata, + ) end function SCIPsetPricerCopy(scip, pricer, pricercopy) - ccall((:SCIPsetPricerCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricercopy) + ccall( + (:SCIPsetPricerCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), + scip, + pricer, + pricercopy, + ) end function SCIPsetPricerFree(scip, pricer, pricerfree) - ccall((:SCIPsetPricerFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerfree) + ccall( + (:SCIPsetPricerFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), + scip, + pricer, + pricerfree, + ) end function SCIPsetPricerInit(scip, pricer, pricerinit) - ccall((:SCIPsetPricerInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinit) + ccall( + (:SCIPsetPricerInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), + scip, + pricer, + pricerinit, + ) end function SCIPsetPricerExit(scip, pricer, pricerexit) - ccall((:SCIPsetPricerExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexit) + ccall( + (:SCIPsetPricerExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), + scip, + pricer, + pricerexit, + ) end function SCIPsetPricerInitsol(scip, pricer, pricerinitsol) - ccall((:SCIPsetPricerInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerinitsol) + ccall( + (:SCIPsetPricerInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), + scip, + pricer, + pricerinitsol, + ) end function SCIPsetPricerExitsol(scip, pricer, pricerexitsol) - ccall((:SCIPsetPricerExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), scip, pricer, pricerexitsol) + ccall( + (:SCIPsetPricerExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}, Ptr{Cvoid}), + scip, + pricer, + pricerexitsol, + ) end function SCIPfindPricer(scip, name) - ccall((:SCIPfindPricer, libscip), Ptr{SCIP_PRICER}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindPricer, libscip), + Ptr{SCIP_PRICER}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetPricers(scip) @@ -7254,75 +17952,231 @@ function SCIPgetNActivePricers(scip) end function SCIPsetPricerPriority(scip, pricer, priority) - ccall((:SCIPsetPricerPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}, Cint), scip, pricer, priority) + ccall( + (:SCIPsetPricerPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}, Cint), + scip, + pricer, + priority, + ) end function SCIPactivatePricer(scip, pricer) - ccall((:SCIPactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}), scip, pricer) + ccall( + (:SCIPactivatePricer, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}), + scip, + pricer, + ) end function SCIPdeactivatePricer(scip, pricer) - ccall((:SCIPdeactivatePricer, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PRICER}), scip, pricer) -end - -function SCIPcreateProb(scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) - ccall((:SCIPcreateProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_PROBDATA}), scip, name, probdelorig, probtrans, probdeltrans, probinitsol, probexitsol, probcopy, probdata) + ccall( + (:SCIPdeactivatePricer, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PRICER}), + scip, + pricer, + ) +end + +function SCIPcreateProb( + scip, + name, + probdelorig, + probtrans, + probdeltrans, + probinitsol, + probexitsol, + probcopy, + probdata, +) + ccall( + (:SCIPcreateProb, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + 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}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPcreateProbBasic, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPsetProbDelorig(scip, probdelorig) - ccall((:SCIPsetProbDelorig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probdelorig) + ccall( + (:SCIPsetProbDelorig, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cvoid}), + scip, + probdelorig, + ) end function SCIPsetProbTrans(scip, probtrans) - ccall((:SCIPsetProbTrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probtrans) + ccall( + (:SCIPsetProbTrans, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cvoid}), + scip, + probtrans, + ) end function SCIPsetProbDeltrans(scip, probdeltrans) - ccall((:SCIPsetProbDeltrans, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probdeltrans) + ccall( + (:SCIPsetProbDeltrans, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cvoid}), + scip, + probdeltrans, + ) end function SCIPsetProbInitsol(scip, probinitsol) - ccall((:SCIPsetProbInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probinitsol) + ccall( + (:SCIPsetProbInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cvoid}), + scip, + probinitsol, + ) end function SCIPsetProbExitsol(scip, probexitsol) - ccall((:SCIPsetProbExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probexitsol) + ccall( + (:SCIPsetProbExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cvoid}), + scip, + probexitsol, + ) end function SCIPsetProbCopy(scip, probcopy) - ccall((:SCIPsetProbCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}), scip, probcopy) + ccall( + (:SCIPsetProbCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cvoid}), + scip, + probcopy, + ) end function SCIPreadProb(scip, filename, extension) - ccall((:SCIPreadProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), scip, filename, extension) + ccall( + (:SCIPreadProb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}), + scip, + filename, + extension, + ) end function SCIPprintOrigProblem(scip, file, extension, genericnames) - ccall((:SCIPprintOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint), scip, file, extension, genericnames) + ccall( + (:SCIPprintOrigProblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint), + scip, + file, + extension, + genericnames, + ) end function SCIPprintTransProblem(scip, file, extension, genericnames) - ccall((:SCIPprintTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint), scip, file, extension, genericnames) + ccall( + (:SCIPprintTransProblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint), + scip, + file, + extension, + genericnames, + ) end function SCIPwriteOrigProblem(scip, filename, extension, genericnames) - ccall((:SCIPwriteOrigProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint), scip, filename, extension, genericnames) + ccall( + (:SCIPwriteOrigProblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint), + scip, + filename, + extension, + genericnames, + ) end function SCIPwriteTransProblem(scip, filename, extension, genericnames) - ccall((:SCIPwriteTransProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint), scip, filename, extension, genericnames) + ccall( + (:SCIPwriteTransProblem, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint), + scip, + filename, + extension, + genericnames, + ) end function SCIPfreeProb(scip) ccall((:SCIPfreeProb, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPpermuteProb(scip, randseed, permuteconss, permutebinvars, permuteintvars, permutebinimplvars, permuteintimplvars, permutecontimplvars, permutecontvars) - ccall((:SCIPpermuteProb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, randseed, permuteconss, permutebinvars, permuteintvars, permutebinimplvars, permuteintimplvars, permutecontimplvars, permutecontvars) +function SCIPpermuteProb( + scip, + randseed, + permuteconss, + permutebinvars, + permuteintvars, + permutebinimplvars, + permuteintimplvars, + permutecontimplvars, + permutecontvars, +) + ccall( + (:SCIPpermuteProb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), + scip, + randseed, + permuteconss, + permutebinvars, + permuteintvars, + permutebinimplvars, + permuteintimplvars, + permutecontimplvars, + permutecontvars, + ) end function SCIPgetProbData(scip) @@ -7330,7 +18184,13 @@ function SCIPgetProbData(scip) end function SCIPsetProbData(scip, probdata) - ccall((:SCIPsetProbData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROBDATA}), scip, probdata) + ccall( + (:SCIPsetProbData, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROBDATA}), + scip, + probdata, + ) end function SCIPgetProbName(scip) @@ -7338,11 +18198,26 @@ function SCIPgetProbName(scip) end function SCIPsetProbName(scip, name) - ccall((:SCIPsetProbName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPsetProbName, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPchgReoptObjective(scip, objsense, vars, coefs, nvars) - ccall((:SCIPchgReoptObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), scip, objsense, vars, coefs, nvars) + ccall( + (:SCIPchgReoptObjective, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, SCIP_OBJSENSE, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), + scip, + objsense, + vars, + coefs, + nvars, + ) end function SCIPgetObjsense(scip) @@ -7350,19 +18225,43 @@ function SCIPgetObjsense(scip) end function SCIPsetObjsense(scip, objsense) - ccall((:SCIPsetObjsense, libscip), SCIP_RETCODE, (Ptr{SCIP}, SCIP_OBJSENSE), scip, objsense) + ccall( + (:SCIPsetObjsense, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, SCIP_OBJSENSE), + scip, + objsense, + ) end function SCIPaddObjoffset(scip, addval) - ccall((:SCIPaddObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) + ccall( + (:SCIPaddObjoffset, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + addval, + ) end function SCIPaddOrigObjoffsetExact(scip, addval) - ccall((:SCIPaddOrigObjoffsetExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, addval) + ccall( + (:SCIPaddOrigObjoffsetExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), + scip, + addval, + ) end function SCIPaddOrigObjoffset(scip, addval) - ccall((:SCIPaddOrigObjoffset, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, addval) + ccall( + (:SCIPaddOrigObjoffset, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + addval, + ) end function SCIPgetOrigObjoffset(scip) @@ -7370,7 +18269,12 @@ function SCIPgetOrigObjoffset(scip) end function SCIPgetOrigObjoffsetExact(scip) - ccall((:SCIPgetOrigObjoffsetExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetOrigObjoffsetExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetOrigObjscale(scip) @@ -7386,7 +18290,13 @@ function SCIPgetTransObjscale(scip) end function SCIPsetObjlimit(scip, objlimit) - ccall((:SCIPsetObjlimit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, objlimit) + ccall( + (:SCIPsetObjlimit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + objlimit, + ) end function SCIPgetObjlimit(scip) @@ -7406,19 +18316,66 @@ function SCIPgetObjNorm(scip) end function SCIPaddVar(scip, var) - ccall((:SCIPaddVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPaddVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPaddPricedVar(scip, var, score) - ccall((:SCIPaddPricedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, score) + ccall( + (:SCIPaddPricedVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + score, + ) end function SCIPdelVar(scip, var, deleted) - ccall((:SCIPdelVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cuint}), scip, var, deleted) -end - -function SCIPgetVarsData(scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) - ccall((:SCIPgetVarsData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars) + ccall( + (:SCIPdelVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cuint}), + 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) @@ -7469,8 +18426,35 @@ 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) +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) @@ -7513,12 +18497,54 @@ function SCIPgetNTotalVars(scip) ccall((:SCIPgetNTotalVars, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPgetSolVarsData(scip, sol, vars, nvars, nbinvars, nintvars, nbinimplvars, nintimplvars, ncontimplvars, 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}, Ptr{Cint}, Ptr{Cint}), scip, sol, vars, nvars, nbinvars, nintvars, nbinimplvars, nintimplvars, ncontimplvars, ncontvars) +function SCIPgetSolVarsData( + scip, + sol, + vars, + nvars, + nbinvars, + nintvars, + nbinimplvars, + nintimplvars, + ncontimplvars, + 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}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + sol, + vars, + nvars, + nbinvars, + nintvars, + nbinimplvars, + nintimplvars, + ncontimplvars, + ncontvars, + ) end function SCIPfindVar(scip, name) - ccall((:SCIPfindVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPallVarsInProb(scip) @@ -7526,23 +18552,54 @@ function SCIPallVarsInProb(scip) end function SCIPaddCons(scip, cons) - ccall((:SCIPaddCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPaddCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPaddConsUpgrade(scip, oldcons, newcons) - ccall((:SCIPaddConsUpgrade, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), scip, oldcons, newcons) + ccall( + (:SCIPaddConsUpgrade, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_CONS}}), + scip, + oldcons, + newcons, + ) end function SCIPdelCons(scip, cons) - ccall((:SCIPdelCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPdelCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPfindOrigCons(scip, name) - ccall((:SCIPfindOrigCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindOrigCons, libscip), + Ptr{SCIP_CONS}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPfindCons(scip, name) - ccall((:SCIPfindCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindCons, libscip), + Ptr{SCIP_CONS}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetNUpgrConss(scip) @@ -7569,28 +18626,86 @@ 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{Ptr{SCIP_CONS}}, Ptr{SCIP_NODE}, SCIP_CONFTYPE, Cuint), scip, node, cons, validnode, conftype, iscutoffinvolved) +function SCIPaddConflict( + scip, + node, + cons, + validnode, + conftype, + iscutoffinvolved, +) + ccall( + (:SCIPaddConflict, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NODE}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{SCIP_NODE}, + SCIP_CONFTYPE, + Cuint, + ), + scip, + node, + cons, + validnode, + conftype, + iscutoffinvolved, + ) end function SCIPclearConflictStore(scip, event) - ccall((:SCIPclearConflictStore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EVENT}), scip, event) + ccall( + (:SCIPclearConflictStore, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EVENT}), + scip, + event, + ) end function SCIPaddConsNode(scip, node, cons, validnode) - ccall((:SCIPaddConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, node, cons, validnode) + ccall( + (:SCIPaddConsNode, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), + scip, + node, + cons, + validnode, + ) end function SCIPaddConsLocal(scip, cons, validnode) - ccall((:SCIPaddConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), scip, cons, validnode) + ccall( + (:SCIPaddConsLocal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_NODE}), + scip, + cons, + validnode, + ) end function SCIPdelConsNode(scip, node, cons) - ccall((:SCIPdelConsNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}), scip, node, cons) + ccall( + (:SCIPdelConsNode, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_CONS}), + scip, + node, + cons, + ) end function SCIPdelConsLocal(scip, cons) - ccall((:SCIPdelConsLocal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPdelConsLocal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetLocalOrigEstimate(scip) @@ -7610,31 +18725,76 @@ function SCIPgetLocalLowerbound(scip) end function SCIPgetNodeDualbound(scip, node) - ccall((:SCIPgetNodeDualbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall( + (:SCIPgetNodeDualbound, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) end function SCIPgetNodeLowerbound(scip, node) - ccall((:SCIPgetNodeLowerbound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall( + (:SCIPgetNodeLowerbound, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) end function SCIPupdateLocalDualbound(scip, newbound) - ccall((:SCIPupdateLocalDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) + ccall( + (:SCIPupdateLocalDualbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + newbound, + ) end function SCIPupdateLocalLowerbound(scip, newbound) - ccall((:SCIPupdateLocalLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, newbound) + ccall( + (:SCIPupdateLocalLowerbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + newbound, + ) end function SCIPupdateNodeDualbound(scip, node, newbound) - ccall((:SCIPupdateNodeDualbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) + ccall( + (:SCIPupdateNodeDualbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), + scip, + node, + newbound, + ) end function SCIPupdateNodeLowerbound(scip, node, newbound) - ccall((:SCIPupdateNodeLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, node, newbound) + ccall( + (:SCIPupdateNodeLowerbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), + scip, + node, + newbound, + ) end function SCIPchgChildPrio(scip, child, priority) - ccall((:SCIPchgChildPrio, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), scip, child, priority) + ccall( + (:SCIPchgChildPrio, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Cdouble), + scip, + child, + priority, + ) end function SCIPinProbing(scip) @@ -7654,7 +18814,13 @@ function SCIPgetProbingDepth(scip) end function SCIPbacktrackProbing(scip, probingdepth) - ccall((:SCIPbacktrackProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint), scip, probingdepth) + ccall( + (:SCIPbacktrackProbing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint), + scip, + probingdepth, + ) end function SCIPendProbing(scip) @@ -7662,23 +18828,57 @@ function SCIPendProbing(scip) end function SCIPchgVarLbProbing(scip, var, newbound) - ccall((:SCIPchgVarLbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall( + (:SCIPchgVarLbProbing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newbound, + ) end function SCIPchgVarUbProbing(scip, var, newbound) - ccall((:SCIPchgVarUbProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall( + (:SCIPchgVarUbProbing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newbound, + ) end function SCIPgetVarObjProbing(scip, var) - ccall((:SCIPgetVarObjProbing, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarObjProbing, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPfixVarProbing(scip, var, fixedval) - ccall((:SCIPfixVarProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, fixedval) + ccall( + (:SCIPfixVarProbing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + fixedval, + ) end function SCIPchgVarObjProbing(scip, var, newobj) - ccall((:SCIPchgVarObjProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) + ccall( + (:SCIPchgVarObjProbing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newobj, + ) end function SCIPisObjChangedProbing(scip) @@ -7686,119 +18886,505 @@ function SCIPisObjChangedProbing(scip) end function SCIPpropagateProbing(scip, maxproprounds, cutoff, ndomredsfound) - ccall((:SCIPpropagateProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Clonglong}), scip, maxproprounds, cutoff, ndomredsfound) + ccall( + (:SCIPpropagateProbing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Clonglong}), + scip, + maxproprounds, + cutoff, + ndomredsfound, + ) end function SCIPpropagateProbingImplications(scip, cutoff) - ccall((:SCIPpropagateProbingImplications, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, cutoff) + ccall( + (:SCIPpropagateProbingImplications, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}), + scip, + cutoff, + ) end function SCIPsolveProbingLP(scip, itlim, lperror, cutoff) - ccall((:SCIPsolveProbingLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, itlim, lperror, cutoff) -end - -function SCIPsolveProbingLPWithPricing(scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) - ccall((:SCIPsolveProbingLPWithPricing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Cuint, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, pretendroot, displayinfo, maxpricerounds, lperror, cutoff) + ccall( + (:SCIPsolveProbingLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), + scip, + itlim, + lperror, + cutoff, + ) +end + +function SCIPsolveProbingLPWithPricing( + scip, + pretendroot, + displayinfo, + maxpricerounds, + lperror, + cutoff, +) + ccall( + (:SCIPsolveProbingLPWithPricing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint, Cuint, Cint, Ptr{Cuint}, Ptr{Cuint}), + 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}}, Cuint, Cuint), scip, lpistate, lpinorms, primalfeas, dualfeas) + ccall( + (:SCIPsetProbingLPState, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_LPISTATE}}, + Ptr{Ptr{SCIP_LPINORMS}}, + Cuint, + Cuint, + ), + scip, + lpistate, + lpinorms, + primalfeas, + dualfeas, + ) end function SCIPaddRowProbing(scip, row) - ccall((:SCIPaddRowProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, row) + ccall( + (:SCIPaddRowProbing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + row, + ) end function SCIPapplyCutsProbing(scip, cutoff) - ccall((:SCIPapplyCutsProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, cutoff) + ccall( + (:SCIPapplyCutsProbing, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}), + scip, + cutoff, + ) end function SCIPsolveProbingRelax(scip, cutoff) - ccall((:SCIPsolveProbingRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, cutoff) + ccall( + (:SCIPsolveProbingRelax, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}), + scip, + cutoff, + ) end function SCIPsnprintfProbingStats(scip, strbuf, len) - ccall((:SCIPsnprintfProbingStats, libscip), Ptr{Cchar}, (Ptr{SCIP}, Ptr{Cchar}, Cint), scip, strbuf, len) -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{Cuint}), scip, diveset, divetype, divecand, divecandsol, divecandfrac, candscore, roundup) + ccall( + (:SCIPsnprintfProbingStats, libscip), + Ptr{Cchar}, + (Ptr{SCIP}, Ptr{Cchar}, Cint), + scip, + strbuf, + len, + ) +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{Cuint}, + ), + scip, + diveset, + divetype, + divecand, + divecandsol, + divecandfrac, + candscore, + roundup, + ) end function SCIPupdateDivesetLPStats(scip, diveset, niterstoadd, divecontext) - ccall((:SCIPupdateDivesetLPStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Clonglong, SCIP_DIVECONTEXT), scip, diveset, niterstoadd, divecontext) -end - -function SCIPupdateDivesetStats(scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol, divecontext) - ccall((:SCIPupdateDivesetStats, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Cint, Cint, Clonglong, Clonglong, Clonglong, Cuint, SCIP_DIVECONTEXT), scip, diveset, nprobingnodes, nbacktracks, nsolsfound, nbestsolsfound, nconflictsfound, leavewassol, divecontext) + ccall( + (:SCIPupdateDivesetLPStats, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Clonglong, SCIP_DIVECONTEXT), + scip, + diveset, + niterstoadd, + divecontext, + ) +end + +function SCIPupdateDivesetStats( + scip, + diveset, + nprobingnodes, + nbacktracks, + nsolsfound, + nbestsolsfound, + nconflictsfound, + leavewassol, + divecontext, +) + ccall( + (:SCIPupdateDivesetStats, libscip), + Cvoid, + ( + Ptr{SCIP}, + Ptr{SCIP_DIVESET}, + Cint, + Cint, + Clonglong, + Clonglong, + Clonglong, + Cuint, + SCIP_DIVECONTEXT, + ), + scip, + diveset, + nprobingnodes, + nbacktracks, + nsolsfound, + nbestsolsfound, + nconflictsfound, + leavewassol, + divecontext, + ) end function SCIPgetDiveBoundChanges(scip, diveset, sol, success, infeasible) - ccall((:SCIPgetDiveBoundChanges, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{Cuint}, Ptr{Cuint}), scip, diveset, sol, success, infeasible) + ccall( + (:SCIPgetDiveBoundChanges, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}, Ptr{Cuint}, Ptr{Cuint}), + 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, Cuint), 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}, Cuint), scip, variables, directions, values, ndivebdchgs, preferred) + ccall( + (:SCIPaddDiveBoundChange, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble, Cuint), + 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}, + Cuint, + ), + scip, + variables, + directions, + values, + ndivebdchgs, + preferred, + ) end function SCIPclearDiveBoundChanges(scip) ccall((:SCIPclearDiveBoundChanges, libscip), Cvoid, (Ptr{SCIP},), scip) end -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}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cuint, SCIP_PROPTIMING, Ptr{Cvoid}, Ptr{SCIP_PROPDATA}), scip, propptr, name, desc, priority, freq, delay, timingmask, propexec, propdata) +function SCIPincludeProp( + scip, + name, + desc, + priority, + freq, + delay, + timingmask, + presolpriority, + presolmaxrounds, + presoltiming, + propcopy, + propfree, + propinit, + propexit, + propinitpre, + propexitpre, + propinitsol, + propexitsol, + proppresol, + propexec, + propresprop, + propdata, +) + ccall( + (:SCIPincludeProp, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Cuint, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Cuint, + SCIP_PROPTIMING, + Ptr{Cvoid}, + Ptr{SCIP_PROPDATA}, + ), + scip, + propptr, + name, + desc, + priority, + freq, + delay, + timingmask, + propexec, + propdata, + ) end function SCIPsetPropCopy(scip, prop, propcopy) - ccall((:SCIPsetPropCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propcopy) + ccall( + (:SCIPsetPropCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), + scip, + prop, + propcopy, + ) end function SCIPsetPropFree(scip, prop, propfree) - ccall((:SCIPsetPropFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propfree) + ccall( + (:SCIPsetPropFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), + scip, + prop, + propfree, + ) end function SCIPsetPropInit(scip, prop, propinit) - ccall((:SCIPsetPropInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinit) + ccall( + (:SCIPsetPropInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), + scip, + prop, + propinit, + ) end function SCIPsetPropExit(scip, prop, propexit) - ccall((:SCIPsetPropExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexit) + ccall( + (:SCIPsetPropExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), + scip, + prop, + propexit, + ) end function SCIPsetPropInitsol(scip, prop, propinitsol) - ccall((:SCIPsetPropInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitsol) + ccall( + (:SCIPsetPropInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), + scip, + prop, + propinitsol, + ) end function SCIPsetPropExitsol(scip, prop, propexitsol) - ccall((:SCIPsetPropExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitsol) + ccall( + (:SCIPsetPropExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), + scip, + prop, + propexitsol, + ) end function SCIPsetPropInitpre(scip, prop, propinitpre) - ccall((:SCIPsetPropInitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propinitpre) + ccall( + (:SCIPsetPropInitpre, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), + scip, + prop, + propinitpre, + ) end function SCIPsetPropExitpre(scip, prop, propexitpre) - ccall((:SCIPsetPropExitpre, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}), scip, prop, propexitpre) -end - -function SCIPsetPropPresol(scip, prop, proppresol, presolpriority, presolmaxrounds, presoltiming) - ccall((:SCIPsetPropPresol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Cvoid}, Cint, Cint, SCIP_PRESOLTIMING), scip, prop, proppresol, presolpriority, presolmaxrounds, presoltiming) + ccall( + (: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) + 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}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindProp, libscip), + Ptr{SCIP_PROP}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetProps(scip) @@ -7810,55 +19396,187 @@ function SCIPgetNProps(scip) end function SCIPsetPropPriority(scip, prop, priority) - ccall((:SCIPsetPropPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, priority) + ccall( + (:SCIPsetPropPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), + scip, + prop, + priority, + ) end function SCIPsetPropPresolPriority(scip, prop, presolpriority) - ccall((:SCIPsetPropPresolPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), scip, prop, presolpriority) + ccall( + (:SCIPsetPropPresolPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}, Cint), + scip, + prop, + presolpriority, + ) end function SCIPcreateRandom(scip, randnumgen, initialseed, useglobalseed) - ccall((:SCIPcreateRandom, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}, Cuint, Cuint), scip, randnumgen, initialseed, useglobalseed) + ccall( + (:SCIPcreateRandom, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}, Cuint, Cuint), + scip, + randnumgen, + initialseed, + useglobalseed, + ) end function SCIPfreeRandom(scip, randnumgen) - ccall((:SCIPfreeRandom, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}), scip, randnumgen) + ccall( + (:SCIPfreeRandom, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{SCIP_RANDNUMGEN}}), + scip, + randnumgen, + ) end function SCIPsetRandomSeed(scip, randnumgen, seed) - ccall((:SCIPsetRandomSeed, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RANDNUMGEN}, Cuint), scip, randnumgen, seed) + ccall( + (:SCIPsetRandomSeed, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_RANDNUMGEN}, Cuint), + scip, + randnumgen, + seed, + ) end function SCIPinitializeRandomSeed(scip, initialseedvalue) - ccall((:SCIPinitializeRandomSeed, libscip), Cuint, (Ptr{SCIP}, Cuint), scip, initialseedvalue) -end - -function SCIPincludeReader(scip, name, desc, extension, readercopy, readerfree, readerread, readerwrite, readerdata) - ccall((:SCIPincludeReader, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{SCIP_READERDATA}), scip, readerptr, name, desc, extension, readerdata) + ccall( + (:SCIPinitializeRandomSeed, libscip), + Cuint, + (Ptr{SCIP}, Cuint), + scip, + initialseedvalue, + ) +end + +function SCIPincludeReader( + scip, + name, + desc, + extension, + readercopy, + readerfree, + readerread, + readerwrite, + readerdata, +) + ccall( + (:SCIPincludeReader, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cchar}, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{SCIP_READERDATA}, + ), + scip, + readerptr, + name, + desc, + extension, + readerdata, + ) end function SCIPsetReaderCopy(scip, reader, readercopy) - ccall((:SCIPsetReaderCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readercopy) + ccall( + (:SCIPsetReaderCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), + scip, + reader, + readercopy, + ) end function SCIPsetReaderFree(scip, reader, readerfree) - ccall((:SCIPsetReaderFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerfree) + ccall( + (:SCIPsetReaderFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), + scip, + reader, + readerfree, + ) end function SCIPsetReaderRead(scip, reader, readerread) - ccall((:SCIPsetReaderRead, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerread) + ccall( + (:SCIPsetReaderRead, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), + scip, + reader, + readerread, + ) end function SCIPsetReaderWrite(scip, reader, readerwrite) - ccall((:SCIPsetReaderWrite, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), scip, reader, readerwrite) + ccall( + (:SCIPsetReaderWrite, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cvoid}), + scip, + reader, + readerwrite, + ) end function SCIPfindReader(scip, name) - ccall((:SCIPfindReader, libscip), Ptr{SCIP_READER}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindReader, libscip), + Ptr{SCIP_READER}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetReaders(scip) @@ -7869,40 +19587,163 @@ function SCIPgetNReaders(scip) ccall((:SCIPgetNReaders, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPincludeRelax(scip, name, desc, priority, freq, relaxcopy, relaxfree, relaxinit, relaxexit, relaxinitsol, relaxexitsol, relaxexec, relaxdata) - ccall((:SCIPincludeRelax, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_RELAXDATA}), scip, relaxptr, name, desc, priority, freq, relaxexec, relaxdata) +function SCIPincludeRelax( + scip, + name, + desc, + priority, + freq, + relaxcopy, + relaxfree, + relaxinit, + relaxexit, + relaxinitsol, + relaxexitsol, + relaxexec, + relaxdata, +) + ccall( + (:SCIPincludeRelax, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Ptr{Cvoid}, + Ptr{SCIP_RELAXDATA}, + ), + scip, + relaxptr, + name, + desc, + priority, + freq, + relaxexec, + relaxdata, + ) end function SCIPsetRelaxCopy(scip, relax, relaxcopy) - ccall((:SCIPsetRelaxCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxcopy) + ccall( + (:SCIPsetRelaxCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), + scip, + relax, + relaxcopy, + ) end function SCIPsetRelaxFree(scip, relax, relaxfree) - ccall((:SCIPsetRelaxFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxfree) + ccall( + (:SCIPsetRelaxFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), + scip, + relax, + relaxfree, + ) end function SCIPsetRelaxInit(scip, relax, relaxinit) - ccall((:SCIPsetRelaxInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinit) + ccall( + (:SCIPsetRelaxInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), + scip, + relax, + relaxinit, + ) end function SCIPsetRelaxExit(scip, relax, relaxexit) - ccall((:SCIPsetRelaxExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexit) + ccall( + (:SCIPsetRelaxExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), + scip, + relax, + relaxexit, + ) end function SCIPsetRelaxInitsol(scip, relax, relaxinitsol) - ccall((:SCIPsetRelaxInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxinitsol) + ccall( + (:SCIPsetRelaxInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), + scip, + relax, + relaxinitsol, + ) end function SCIPsetRelaxExitsol(scip, relax, relaxexitsol) - ccall((:SCIPsetRelaxExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), scip, relax, relaxexitsol) + ccall( + (:SCIPsetRelaxExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{Cvoid}), + scip, + relax, + relaxexitsol, + ) end function SCIPfindRelax(scip, name) - ccall((:SCIPfindRelax, libscip), Ptr{SCIP_RELAX}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindRelax, libscip), + Ptr{SCIP_RELAX}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetRelaxs(scip) @@ -7914,115 +19755,485 @@ function SCIPgetNRelaxs(scip) end function SCIPsetRelaxPriority(scip, relax, priority) - ccall((:SCIPsetRelaxPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint), scip, relax, priority) + ccall( + (:SCIPsetRelaxPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint), + scip, + relax, + priority, + ) end function SCIPgetReoptChildIDs(scip, node, ids, idssize, nids) - ccall((:SCIPgetReoptChildIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}, Cint, Ptr{Cint}), scip, node, ids, idssize, nids) + ccall( + (:SCIPgetReoptChildIDs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}, Cint, Ptr{Cint}), + scip, + node, + ids, + idssize, + nids, + ) end function SCIPgetReoptLeaveIDs(scip, node, ids, idssize, nids) - ccall((:SCIPgetReoptLeaveIDs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}, Cint, Ptr{Cint}), scip, node, ids, idssize, nids) + ccall( + (:SCIPgetReoptLeaveIDs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}, Cint, Ptr{Cint}), + scip, + node, + ids, + idssize, + nids, + ) end function SCIPgetNReoptnodes(scip, node) - ccall((:SCIPgetNReoptnodes, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall( + (:SCIPgetNReoptnodes, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) end function SCIPgetNReoptLeaves(scip, node) - ccall((:SCIPgetNReoptLeaves, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall( + (:SCIPgetNReoptLeaves, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) end function SCIPgetReoptnode(scip, id) - ccall((:SCIPgetReoptnode, libscip), Ptr{SCIP_REOPTNODE}, (Ptr{SCIP}, Cuint), scip, id) + ccall( + (:SCIPgetReoptnode, libscip), + Ptr{SCIP_REOPTNODE}, + (Ptr{SCIP}, Cuint), + 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{Cuint}), 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, Cuint), scip, reoptnode, vars, vals, boundtypes, lhs, rhs, nvars, constype, linear) -end - -function SCIPgetReoptnodePath(scip, reoptnode, vars, vals, boundtypes, mem, nvars, nafterdualvars) - ccall((:SCIPgetReoptnodePath, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Cint, Ptr{Cint}, Ptr{Cint}), scip, reoptnode, vars, vals, boundtypes, mem, nvars, nafterdualvars) + ccall( + (: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{Cuint}), + 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, + Cuint, + ), + 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) + ccall( + (:SCIPinitRepresentation, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), + scip, + representatives, + nrepresentatives, + ) end function SCIPresetRepresentation(scip, representatives, nrepresentatives) - ccall((:SCIPresetRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) + ccall( + (:SCIPresetRepresentation, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), + scip, + representatives, + nrepresentatives, + ) end function SCIPfreeRepresentation(scip, representatives, nrepresentatives) - ccall((:SCIPfreeRepresentation, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}, Cint), scip, representatives, nrepresentatives) -end - -function SCIPapplyReopt(scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) - ccall((:SCIPapplyReopt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_REOPTNODE}, Cuint, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cuint}), scip, reoptnode, id, estimate, childnodes, ncreatedchilds, naddedconss, childnodessize, success) + 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}, + Cuint, + Cdouble, + Ptr{Ptr{SCIP_NODE}}, + Ptr{Cint}, + Ptr{Cint}, + Cint, + Ptr{Cuint}, + ), + scip, + reoptnode, + id, + estimate, + childnodes, + ncreatedchilds, + naddedconss, + childnodessize, + success, + ) end function SCIPresetReoptnodeDualcons(scip, node) - ccall((:SCIPresetReoptnodeDualcons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall( + (:SCIPresetReoptnodeDualcons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) end function SCIPsplitReoptRoot(scip, ncreatedchilds, naddedconss) - ccall((:SCIPsplitReoptRoot, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}), scip, ncreatedchilds, naddedconss) + ccall( + (:SCIPsplitReoptRoot, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cint}, Ptr{Cint}), + scip, + ncreatedchilds, + naddedconss, + ) end function SCIPreoptimizeNode(scip, node) - ccall((:SCIPreoptimizeNode, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall( + (:SCIPreoptimizeNode, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) end function SCIPdeleteReoptnode(scip, reoptnode) - ccall((:SCIPdeleteReoptnode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}), scip, reoptnode) + ccall( + (:SCIPdeleteReoptnode, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_REOPTNODE}}), + scip, + reoptnode, + ) end function SCIPgetReoptSimilarity(scip, run1, run2) - ccall((:SCIPgetReoptSimilarity, libscip), Cdouble, (Ptr{SCIP}, Cint, Cint), scip, run1, run2) -end - -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}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cdouble, Cuint, Cuint, 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}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Cdouble, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_SEPADATA}), scip, sepa, name, desc, priority, freq, maxbounddist, usessubscip, delay, sepaexeclp, sepaexecsol, sepadata) + ccall( + (:SCIPgetReoptSimilarity, libscip), + Cdouble, + (Ptr{SCIP}, Cint, Cint), + scip, + run1, + run2, + ) +end + +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}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Cdouble, + Cuint, + Cuint, + 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}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Cdouble, + Cuint, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_SEPADATA}, + ), + scip, + sepa, + name, + desc, + priority, + freq, + maxbounddist, + usessubscip, + delay, + sepaexeclp, + sepaexecsol, + sepadata, + ) end function SCIPsetSepaCopy(scip, sepa, sepacopy) - ccall((:SCIPsetSepaCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepacopy) + ccall( + (:SCIPsetSepaCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), + scip, + sepa, + sepacopy, + ) end function SCIPsetSepaFree(scip, sepa, sepafree) - ccall((:SCIPsetSepaFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepafree) + ccall( + (:SCIPsetSepaFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), + scip, + sepa, + sepafree, + ) end function SCIPsetSepaInit(scip, sepa, sepainit) - ccall((:SCIPsetSepaInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainit) + ccall( + (:SCIPsetSepaInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), + scip, + sepa, + sepainit, + ) end function SCIPsetSepaExit(scip, sepa, sepaexit) - ccall((:SCIPsetSepaExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexit) + ccall( + (:SCIPsetSepaExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), + scip, + sepa, + sepaexit, + ) end function SCIPsetSepaInitsol(scip, sepa, sepainitsol) - ccall((:SCIPsetSepaInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepainitsol) + ccall( + (:SCIPsetSepaInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), + scip, + sepa, + sepainitsol, + ) end function SCIPsetSepaExitsol(scip, sepa, sepaexitsol) - ccall((:SCIPsetSepaExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), scip, sepa, sepaexitsol) + ccall( + (:SCIPsetSepaExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{Cvoid}), + scip, + sepa, + sepaexitsol, + ) end function SCIPfindSepa(scip, name) - ccall((:SCIPfindSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindSepa, libscip), + Ptr{SCIP_SEPA}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetSepas(scip) @@ -8034,55 +20245,192 @@ function SCIPgetNSepas(scip) end function SCIPsetSepaPriority(scip, sepa, priority) - ccall((:SCIPsetSepaPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Cint), scip, sepa, priority) + ccall( + (:SCIPsetSepaPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SEPA}, Cint), + scip, + sepa, + priority, + ) end function SCIPsetSepaIsParentsepa(scip, sepa) - ccall((:SCIPsetSepaIsParentsepa, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SEPA}), scip, sepa) + ccall( + (:SCIPsetSepaIsParentsepa, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SEPA}), + scip, + sepa, + ) end function SCIPsetSepaParentsepa(scip, sepa, parentsepa) - ccall((:SCIPsetSepaParentsepa, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{SCIP_SEPA}), scip, sepa, parentsepa) + ccall( + (:SCIPsetSepaParentsepa, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SEPA}, Ptr{SCIP_SEPA}), + scip, + sepa, + parentsepa, + ) end function SCIPgetSepaMinEfficacy(scip) ccall((:SCIPgetSepaMinEfficacy, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPincludeCutsel(scip, name, desc, priority, cutselcopy, cutselfree, cutselinit, cutselexit, cutselinitsol, cutselexitsol, cutselselect, cutseldata) - ccall((:SCIPincludeCutsel, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_CUTSELDATA}), scip, name, desc, priority, cutselcopy, cutselfree, cutselinit, cutselexit, cutselinitsol, cutselexitsol, cutselselect, cutseldata) -end - -function SCIPincludeCutselBasic(scip, cutsel, name, desc, priority, cutselselect, cutseldata) - ccall((:SCIPincludeCutselBasic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CUTSEL}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Ptr{Cvoid}, Ptr{SCIP_CUTSELDATA}), scip, cutsel, name, desc, priority, cutselselect, cutseldata) +function SCIPincludeCutsel( + scip, + name, + desc, + priority, + cutselcopy, + cutselfree, + cutselinit, + cutselexit, + cutselinitsol, + cutselexitsol, + cutselselect, + cutseldata, +) + ccall( + (:SCIPincludeCutsel, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_CUTSELDATA}, + ), + scip, + name, + desc, + priority, + cutselcopy, + cutselfree, + cutselinit, + cutselexit, + cutselinitsol, + cutselexitsol, + cutselselect, + cutseldata, + ) +end + +function SCIPincludeCutselBasic( + scip, + cutsel, + name, + desc, + priority, + cutselselect, + cutseldata, +) + ccall( + (:SCIPincludeCutselBasic, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CUTSEL}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Ptr{Cvoid}, + Ptr{SCIP_CUTSELDATA}, + ), + scip, + cutsel, + name, + desc, + priority, + cutselselect, + cutseldata, + ) end function SCIPsetCutselCopy(scip, cutsel, cutselcopy) - ccall((:SCIPsetCutselCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselcopy) + ccall( + (:SCIPsetCutselCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), + scip, + cutsel, + cutselcopy, + ) end function SCIPsetCutselFree(scip, cutsel, cutselfree) - ccall((:SCIPsetCutselFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselfree) + ccall( + (:SCIPsetCutselFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), + scip, + cutsel, + cutselfree, + ) end function SCIPsetCutselInit(scip, cutsel, cutselinit) - ccall((:SCIPsetCutselInit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselinit) + ccall( + (:SCIPsetCutselInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), + scip, + cutsel, + cutselinit, + ) end function SCIPsetCutselExit(scip, cutsel, cutselexit) - ccall((:SCIPsetCutselExit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselexit) + ccall( + (:SCIPsetCutselExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), + scip, + cutsel, + cutselexit, + ) end function SCIPsetCutselInitsol(scip, cutsel, cutselinitsol) - ccall((:SCIPsetCutselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselinitsol) + ccall( + (:SCIPsetCutselInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), + scip, + cutsel, + cutselinitsol, + ) end function SCIPsetCutselExitsol(scip, cutsel, cutselexitsol) - ccall((:SCIPsetCutselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), scip, cutsel, cutselexitsol) + ccall( + (:SCIPsetCutselExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Ptr{Cvoid}), + scip, + cutsel, + cutselexitsol, + ) end function SCIPfindCutsel(scip, name) - ccall((:SCIPfindCutsel, libscip), Ptr{SCIP_CUTSEL}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindCutsel, libscip), + Ptr{SCIP_CUTSEL}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetCutsels(scip) @@ -8094,215 +20442,580 @@ function SCIPgetNCutsels(scip) end function SCIPsetCutselPriority(scip, cutsel, priority) - ccall((:SCIPsetCutselPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Cint), scip, cutsel, priority) + ccall( + (:SCIPsetCutselPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CUTSEL}, Cint), + scip, + cutsel, + priority, + ) end function SCIPcreateSol(scip, sol, heur) - ccall((:SCIPcreateSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateSolExact(scip, sol, heur) - ccall((:SCIPcreateSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateLPSol(scip, sol, heur) - ccall((:SCIPcreateLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateLPSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateLPSolExact(scip, sol, heur) - ccall((:SCIPcreateLPSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateLPSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateNLPSol(scip, sol, heur) - ccall((:SCIPcreateNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateNLPSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateRelaxSol(scip, sol, heur) - ccall((:SCIPcreateRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateRelaxSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreatePseudoSol(scip, sol, heur) - ccall((:SCIPcreatePseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreatePseudoSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateCurrentSol(scip, sol, heur) - ccall((:SCIPcreateCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateCurrentSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreatePartialSol(scip, sol, heur) - ccall((:SCIPcreatePartialSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreatePartialSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateUnknownSol(scip, sol, heur) - ccall((:SCIPcreateUnknownSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateUnknownSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateOrigSol(scip, sol, heur) - ccall((:SCIPcreateOrigSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), scip, sol, heur) + ccall( + (:SCIPcreateOrigSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_HEUR}), + scip, + sol, + heur, + ) end function SCIPcreateSolCopy(scip, sol, sourcesol) - ccall((:SCIPcreateSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) + ccall( + (:SCIPcreateSolCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), + scip, + sol, + sourcesol, + ) end function SCIPcreateSolCopyOrig(scip, sol, sourcesol) - ccall((:SCIPcreateSolCopyOrig, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), scip, sol, sourcesol) + ccall( + (:SCIPcreateSolCopyOrig, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}), + scip, + sol, + sourcesol, + ) end function SCIPcreateFiniteSolCopy(scip, sol, sourcesol, success) - ccall((:SCIPcreateFiniteSolCopy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, sol, sourcesol, success) + ccall( + (:SCIPcreateFiniteSolCopy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{SCIP_SOL}, Ptr{Cuint}), + scip, + sol, + sourcesol, + success, + ) end function SCIPfreeSol(scip, sol) - ccall((:SCIPfreeSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}), scip, sol) + ccall( + (:SCIPfreeSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}), + scip, + sol, + ) end function SCIPlinkLPSol(scip, sol) - ccall((:SCIPlinkLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPlinkLPSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPlinkLPSolExact(scip, sol) - ccall((:SCIPlinkLPSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPlinkLPSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPlinkNLPSol(scip, sol) - ccall((:SCIPlinkNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPlinkNLPSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPlinkRelaxSol(scip, sol) - ccall((:SCIPlinkRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPlinkRelaxSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPlinkPseudoSol(scip, sol) - ccall((:SCIPlinkPseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPlinkPseudoSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPlinkCurrentSol(scip, sol) - ccall((:SCIPlinkCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPlinkCurrentSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPclearSol(scip, sol) - ccall((:SCIPclearSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPclearSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPunlinkSol(scip, sol) - ccall((:SCIPunlinkSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPunlinkSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPunlinkSolExact(scip, sol) - ccall((:SCIPunlinkSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPunlinkSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPsetSolVal(scip, sol, var, val) - ccall((:SCIPsetSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, val) + ccall( + (:SCIPsetSolVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), + scip, + sol, + var, + val, + ) end function SCIPsetSolValExact(scip, sol, var, val) - ccall((:SCIPsetSolValExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, sol, var, val) + ccall( + (:SCIPsetSolValExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + sol, + var, + val, + ) end function SCIPsetSolVals(scip, sol, nvars, vars, vals) - ccall((:SCIPsetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) + ccall( + (:SCIPsetSolVals, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), + scip, + sol, + nvars, + vars, + vals, + ) end function SCIPincSolVal(scip, sol, var, incval) - ccall((:SCIPincSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), scip, sol, var, incval) + ccall( + (:SCIPincSolVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble), + scip, + sol, + var, + incval, + ) end function SCIPgetSolVal(scip, sol, var) - ccall((:SCIPgetSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}), scip, sol, var) + ccall( + (:SCIPgetSolVal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}), + scip, + sol, + var, + ) end function SCIPgetSolValExact(scip, sol, var, res) - ccall((:SCIPgetSolValExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, sol, var, res) + ccall( + (:SCIPgetSolValExact, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + sol, + var, + res, + ) end function SCIPgetSolVals(scip, sol, nvars, vars, vals) - ccall((:SCIPgetSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, sol, nvars, vars, vals) + ccall( + (:SCIPgetSolVals, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), + scip, + sol, + nvars, + vars, + vals, + ) end function SCIPgetSolOrigObj(scip, sol) - ccall((:SCIPgetSolOrigObj, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPgetSolOrigObj, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPgetSolOrigObjExact(scip, sol, res) - ccall((:SCIPgetSolOrigObjExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, sol, res) + ccall( + (:SCIPgetSolOrigObjExact, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), + scip, + sol, + res, + ) end function SCIPgetSolTransObj(scip, sol) - ccall((:SCIPgetSolTransObj, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPgetSolTransObj, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPgetSolTransObjExact(scip, sol, res) - ccall((:SCIPgetSolTransObjExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, sol, res) + ccall( + (:SCIPgetSolTransObjExact, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), + scip, + sol, + res, + ) end function SCIPrecomputeSolObj(scip, sol) - ccall((:SCIPrecomputeSolObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPrecomputeSolObj, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPtransformObj(scip, obj) - ccall((:SCIPtransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) + ccall( + (:SCIPtransformObj, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + obj, + ) end function SCIPretransformObj(scip, obj) - ccall((:SCIPretransformObj, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, obj) + ccall( + (:SCIPretransformObj, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + obj, + ) end function SCIPgetSolTime(scip, sol) - ccall((:SCIPgetSolTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPgetSolTime, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPgetSolRunnum(scip, sol) - ccall((:SCIPgetSolRunnum, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPgetSolRunnum, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPgetSolNodenum(scip, sol) - ccall((:SCIPgetSolNodenum, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPgetSolNodenum, libscip), + Clonglong, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPgetSolHeur(scip, sol) - ccall((:SCIPgetSolHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPgetSolHeur, libscip), + Ptr{SCIP_HEUR}, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPareSolsEqual(scip, sol1, sol2) - ccall((:SCIPareSolsEqual, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{SCIP_SOL}), scip, sol1, sol2) + ccall( + (:SCIPareSolsEqual, libscip), + Cuint, + (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}, Cuint), scip, sol, uselprows) + ccall( + (:SCIPadjustImplicitSolVals, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint), + scip, + sol, + uselprows, + ) end function SCIPprintSol(scip, sol, file, printzeros) - ccall((:SCIPprintSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), scip, sol, file, printzeros) + ccall( + (:SCIPprintSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), + scip, + sol, + file, + printzeros, + ) end function SCIPprintSolExact(scip, sol, file, printzeros) - ccall((:SCIPprintSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), scip, sol, file, printzeros) + ccall( + (:SCIPprintSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), + scip, + sol, + file, + printzeros, + ) end function SCIPprintTransSol(scip, sol, file, printzeros) - ccall((:SCIPprintTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), scip, sol, file, printzeros) + ccall( + (:SCIPprintTransSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), + scip, + sol, + file, + printzeros, + ) end function SCIPprintMIPStart(scip, sol, file) - ccall((:SCIPprintMIPStart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), scip, sol, file) + ccall( + (:SCIPprintMIPStart, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), + scip, + sol, + file, + ) end function SCIPgetDualSolVal(scip, cons, dualsolval, boundconstraint) - ccall((:SCIPgetDualSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), scip, cons, dualsolval, boundconstraint) + ccall( + (:SCIPgetDualSolVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), + scip, + cons, + dualsolval, + boundconstraint, + ) end function SCIPisDualSolAvailable(scip, printreason) - ccall((:SCIPisDualSolAvailable, libscip), Cuint, (Ptr{SCIP}, Cuint), scip, printreason) + ccall( + (:SCIPisDualSolAvailable, libscip), + Cuint, + (Ptr{SCIP}, Cuint), + scip, + printreason, + ) end function SCIPprintDualSol(scip, file, printzeros) - ccall((:SCIPprintDualSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), scip, file, printzeros) + ccall( + (:SCIPprintDualSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), + scip, + file, + printzeros, + ) end function SCIPprintRay(scip, sol, file, printzeros) - ccall((:SCIPprintRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), scip, sol, file, printzeros) + ccall( + (:SCIPprintRay, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}, Cuint), + scip, + sol, + file, + printzeros, + ) end function SCIPgetNSols(scip) @@ -8318,103 +21031,351 @@ function SCIPgetBestSol(scip) end function SCIPprintBestSol(scip, file, printzeros) - ccall((:SCIPprintBestSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), scip, file, printzeros) + ccall( + (:SCIPprintBestSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), + scip, + file, + printzeros, + ) end function SCIPprintBestTransSol(scip, file, printzeros) - ccall((:SCIPprintBestTransSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), scip, file, printzeros) + ccall( + (:SCIPprintBestTransSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Cuint), + scip, + file, + printzeros, + ) end function SCIProundSol(scip, sol, success) - ccall((:SCIProundSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, sol, success) + ccall( + (:SCIProundSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}), + scip, + sol, + success, + ) end function SCIPmakeSolExact(scip, sol) - ccall((:SCIPmakeSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPmakeSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPretransformSol(scip, sol) - ccall((:SCIPretransformSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPretransformSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPretransformSolExact(scip, sol) - ccall((:SCIPretransformSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPretransformSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPreadSol(scip, filename) - ccall((:SCIPreadSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) + ccall( + (:SCIPreadSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + filename, + ) end function SCIPreadSolFile(scip, filename, sol, xml, partial, error) - ccall((:SCIPreadSolFile, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_SOL}, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, filename, sol, xml, partial, error) + ccall( + (:SCIPreadSolFile, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_SOL}, Cuint, Ptr{Cuint}, Ptr{Cuint}), + scip, + filename, + sol, + xml, + partial, + error, + ) end function SCIPaddSol(scip, sol, stored) - ccall((:SCIPaddSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, sol, stored) + ccall( + (:SCIPaddSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}), + scip, + sol, + stored, + ) end function SCIPaddSolFree(scip, sol, stored) - ccall((:SCIPaddSolFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{Cuint}), scip, sol, stored) + ccall( + (:SCIPaddSolFree, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Ptr{Cuint}), + scip, + sol, + stored, + ) end function SCIPaddCurrentSol(scip, heur, stored) - ccall((:SCIPaddCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cuint}), scip, heur, stored) -end - -function SCIPtrySol(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) - ccall((:SCIPtrySol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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}}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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}, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), scip, heur, printreason, completely, checkintegrality, checklprows, stored) + ccall( + (:SCIPaddCurrentSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{Cuint}), + scip, + heur, + stored, + ) +end + +function SCIPtrySol( + scip, + sol, + printreason, + completely, + checkbounds, + checkintegrality, + checklprows, + stored, +) + ccall( + (:SCIPtrySol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_SOL}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + 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}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + 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}, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), + scip, + heur, + printreason, + completely, + checkintegrality, + checklprows, + stored, + ) end function SCIPgetPartialSols(scip) - ccall((:SCIPgetPartialSols, libscip), Ptr{Ptr{SCIP_SOL}}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetPartialSols, libscip), + Ptr{Ptr{SCIP_SOL}}, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNPartialSols(scip) ccall((:SCIPgetNPartialSols, libscip), Cint, (Ptr{SCIP},), scip) end -function SCIPcheckSol(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) - ccall((:SCIPcheckSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) +function SCIPcheckSol( + scip, + sol, + printreason, + completely, + checkbounds, + checkintegrality, + checklprows, + feasible, +) + ccall( + (:SCIPcheckSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_SOL}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + 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{Cuint}, Cuint, Cuint), scip, sol, feasible, printreason, completely) + ccall( + (:SCIPcheckSolOrig, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Cuint}, Cuint, Cuint), + scip, + sol, + feasible, + printreason, + completely, + ) end function SCIPupdateSolIntegralityViolation(scip, sol, absviol) - ccall((:SCIPupdateSolIntegralityViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble), scip, sol, absviol) + ccall( + (:SCIPupdateSolIntegralityViolation, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble), + scip, + sol, + absviol, + ) end function SCIPupdateSolBoundViolation(scip, sol, absviol, relviol) - ccall((:SCIPupdateSolBoundViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) + ccall( + (:SCIPupdateSolBoundViolation, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), + scip, + sol, + absviol, + relviol, + ) end function SCIPupdateSolLPRowViolation(scip, sol, absviol, relviol) - ccall((:SCIPupdateSolLPRowViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) + ccall( + (:SCIPupdateSolLPRowViolation, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), + scip, + sol, + absviol, + relviol, + ) end function SCIPupdateSolConsViolation(scip, sol, absviol, relviol) - ccall((:SCIPupdateSolConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) + ccall( + (:SCIPupdateSolConsViolation, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), + scip, + sol, + absviol, + relviol, + ) end function SCIPupdateSolLPConsViolation(scip, sol, absviol, relviol) - ccall((:SCIPupdateSolLPConsViolation, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), scip, sol, absviol, relviol) + ccall( + (:SCIPupdateSolLPConsViolation, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Cdouble, Cdouble), + scip, + sol, + absviol, + relviol, + ) end function SCIPactivateSolViolationUpdates(scip) - ccall((:SCIPactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall( + (:SCIPactivateSolViolationUpdates, libscip), + Cvoid, + (Ptr{SCIP},), + scip, + ) end function SCIPdeactivateSolViolationUpdates(scip) - ccall((:SCIPdeactivateSolViolationUpdates, libscip), Cvoid, (Ptr{SCIP},), scip) + ccall( + (:SCIPdeactivateSolViolationUpdates, libscip), + Cvoid, + (Ptr{SCIP},), + scip, + ) end function SCIPhasPrimalRay(scip) @@ -8422,19 +21383,67 @@ function SCIPhasPrimalRay(scip) end function SCIPgetPrimalRayVal(scip, var) - ccall((:SCIPgetPrimalRayVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetPrimalRayVal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPupdatePrimalRay(scip, primalray) - ccall((:SCIPupdatePrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, primalray) + ccall( + (:SCIPupdatePrimalRay, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + primalray, + ) end function SCIPoverwriteFPsol(scip, sol) - ccall((:SCIPoverwriteFPsol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) -end - -function SCIPtrySolFreeExact(scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) - ccall((:SCIPtrySolFreeExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_SOL}}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), scip, sol, printreason, completely, checkbounds, checkintegrality, checklprows, stored) + ccall( + (:SCIPoverwriteFPsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) +end + +function SCIPtrySolFreeExact( + scip, + sol, + printreason, + completely, + checkbounds, + checkintegrality, + checklprows, + stored, +) + ccall( + (:SCIPtrySolFreeExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_SOL}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + scip, + sol, + printreason, + completely, + checkbounds, + checkintegrality, + checklprows, + stored, + ) end function SCIPtransformProb(scip) @@ -8454,7 +21463,13 @@ function SCIPsolveConcurrent(scip) end function SCIPfreeSolve(scip, restart) - ccall((:SCIPfreeSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, restart) + ccall( + (:SCIPfreeSolve, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint), + scip, + restart, + ) end function SCIPfreeTransform(scip) @@ -8482,7 +21497,13 @@ function SCIPfreeReoptSolve(scip) end function SCIPenableReoptimization(scip, enable) - ccall((:SCIPenableReoptimization, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, enable) + ccall( + (:SCIPenableReoptimization, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint), + scip, + enable, + ) end function SCIPisReoptEnabled(scip) @@ -8490,7 +21511,16 @@ function SCIPisReoptEnabled(scip) end function SCIPgetReoptSolsRun(scip, run, sols, solssize, nsols) - ccall((:SCIPgetReoptSolsRun, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_SOL}}, Cint, Ptr{Cint}), scip, run, sols, solssize, nsols) + ccall( + (:SCIPgetReoptSolsRun, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_SOL}}, Cint, Ptr{Cint}), + scip, + run, + sols, + solssize, + nsols, + ) end function SCIPresetReoptSolMarks(scip) @@ -8498,11 +21528,27 @@ function SCIPresetReoptSolMarks(scip) end function SCIPcheckReoptRestart(scip, node, restart) - ccall((:SCIPcheckReoptRestart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}), scip, node, restart) + ccall( + (:SCIPcheckReoptRestart, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Cuint}), + scip, + node, + restart, + ) end function SCIPaddReoptDualBndchg(scip, node, var, newbound, oldbound) - ccall((:SCIPaddReoptDualBndchg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, node, var, newbound, oldbound) + ccall( + (:SCIPaddReoptDualBndchg, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + scip, + node, + var, + newbound, + oldbound, + ) end function SCIPgetReoptLastOptSol(scip) @@ -8510,7 +21556,15 @@ function SCIPgetReoptLastOptSol(scip) end function SCIPgetReoptOldObjCoef(scip, var, run, objcoef) - ccall((:SCIPgetReoptOldObjCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), scip, var, run, objcoef) + ccall( + (:SCIPgetReoptOldObjCoef, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Cdouble}), + scip, + var, + run, + objcoef, + ) end function SCIPgetNRuns(scip) @@ -8522,7 +21576,13 @@ function SCIPgetNReoptRuns(scip) end function SCIPaddNNodes(scip, nnodes) - ccall((:SCIPaddNNodes, libscip), Cvoid, (Ptr{SCIP}, Clonglong), scip, nnodes) + ccall( + (:SCIPaddNNodes, libscip), + Cvoid, + (Ptr{SCIP}, Clonglong), + scip, + nnodes, + ) end function SCIPgetNNodes(scip) @@ -8582,7 +21642,12 @@ function SCIPgetNRootLPIterations(scip) end function SCIPgetNRootFirstLPIterations(scip) - ccall((:SCIPgetNRootFirstLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNRootFirstLPIterations, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNPrimalLPs(scip) @@ -8606,7 +21671,12 @@ function SCIPgetNBarrierLPs(scip) end function SCIPgetNBarrierLPIterations(scip) - ccall((:SCIPgetNBarrierLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNBarrierLPIterations, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNResolveLPs(scip) @@ -8614,7 +21684,12 @@ function SCIPgetNResolveLPs(scip) end function SCIPgetNResolveLPIterations(scip) - ccall((:SCIPgetNResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNResolveLPIterations, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNPrimalResolveLPs(scip) @@ -8622,7 +21697,12 @@ function SCIPgetNPrimalResolveLPs(scip) end function SCIPgetNPrimalResolveLPIterations(scip) - ccall((:SCIPgetNPrimalResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNPrimalResolveLPIterations, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNDualResolveLPs(scip) @@ -8630,7 +21710,12 @@ function SCIPgetNDualResolveLPs(scip) end function SCIPgetNDualResolveLPIterations(scip) - ccall((:SCIPgetNDualResolveLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNDualResolveLPIterations, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNNodeLPs(scip) @@ -8638,7 +21723,12 @@ function SCIPgetNNodeLPs(scip) end function SCIPgetNNodeZeroIterationLPs(scip) - ccall((:SCIPgetNNodeZeroIterationLPs, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNNodeZeroIterationLPs, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNNodeLPIterations(scip) @@ -8650,7 +21740,12 @@ function SCIPgetNNodeInitLPs(scip) end function SCIPgetNNodeInitLPIterations(scip) - ccall((:SCIPgetNNodeInitLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNNodeInitLPIterations, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNDivingLPs(scip) @@ -8666,7 +21761,12 @@ function SCIPgetNStrongbranchs(scip) end function SCIPgetNStrongbranchLPIterations(scip) - ccall((:SCIPgetNStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNStrongbranchLPIterations, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNRootStrongbranchs(scip) @@ -8674,7 +21774,12 @@ function SCIPgetNRootStrongbranchs(scip) end function SCIPgetNRootStrongbranchLPIterations(scip) - ccall((:SCIPgetNRootStrongbranchLPIterations, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNRootStrongbranchLPIterations, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNPriceRounds(scip) @@ -8718,15 +21823,30 @@ function SCIPgetNConflictConssFoundNode(scip) end function SCIPgetNConflictConssApplied(scip) - ccall((:SCIPgetNConflictConssApplied, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNConflictConssApplied, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNResConflictConssApplied(scip) - ccall((:SCIPgetNResConflictConssApplied, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNResConflictConssApplied, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetNConflictDualproofsApplied(scip) - ccall((:SCIPgetNConflictDualproofsApplied, libscip), Clonglong, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetNConflictDualproofsApplied, libscip), + Clonglong, + (Ptr{SCIP},), + scip, + ) end function SCIPgetMaxDepth(scip) @@ -8762,7 +21882,13 @@ function SCIPgetDualbound(scip) end function SCIPgetDualboundExact(scip, result) - ccall((:SCIPgetDualboundExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) + ccall( + (:SCIPgetDualboundExact, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), + scip, + result, + ) end function SCIPgetLowerbound(scip) @@ -8770,7 +21896,13 @@ function SCIPgetLowerbound(scip) end function SCIPgetLowerboundExact(scip, result) - ccall((:SCIPgetLowerboundExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) + ccall( + (:SCIPgetLowerboundExact, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), + scip, + result, + ) end function SCIPgetDualboundRoot(scip) @@ -8798,7 +21930,13 @@ function SCIPgetPrimalbound(scip) end function SCIPgetPrimalboundExact(scip, result) - ccall((:SCIPgetPrimalboundExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) + ccall( + (:SCIPgetPrimalboundExact, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), + scip, + result, + ) end function SCIPgetUpperbound(scip) @@ -8806,7 +21944,13 @@ function SCIPgetUpperbound(scip) end function SCIPgetUpperboundExact(scip, result) - ccall((:SCIPgetUpperboundExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) + ccall( + (:SCIPgetUpperboundExact, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), + scip, + result, + ) end function SCIPgetCutoffbound(scip) @@ -8814,11 +21958,22 @@ function SCIPgetCutoffbound(scip) end function SCIPgetCutoffboundExact(scip) - ccall((:SCIPgetCutoffboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetCutoffboundExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP},), + scip, + ) end function SCIPupdateCutoffbound(scip, cutoffbound) - ccall((:SCIPupdateCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble), scip, cutoffbound) + ccall( + (:SCIPupdateCutoffbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cdouble), + scip, + cutoffbound, + ) end function SCIPisPrimalboundSol(scip) @@ -8846,23 +22001,54 @@ function SCIPgetNBestSolsFound(scip) end function SCIPgetAvgPseudocost(scip, solvaldelta) - ccall((:SCIPgetAvgPseudocost, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) + ccall( + (:SCIPgetAvgPseudocost, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + solvaldelta, + ) end function SCIPgetAvgPseudocostCurrentRun(scip, solvaldelta) - ccall((:SCIPgetAvgPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, solvaldelta) + ccall( + (:SCIPgetAvgPseudocostCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + solvaldelta, + ) end function SCIPgetAvgPseudocostCount(scip, dir) - ccall((:SCIPgetAvgPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall( + (:SCIPgetAvgPseudocostCount, libscip), + Cdouble, + (Ptr{SCIP}, SCIP_BRANCHDIR), + scip, + dir, + ) end function SCIPgetAvgPseudocostCountCurrentRun(scip, dir) - ccall((:SCIPgetAvgPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall( + (:SCIPgetAvgPseudocostCountCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, SCIP_BRANCHDIR), + scip, + dir, + ) end function SCIPgetPseudocostCount(scip, dir, onlycurrentrun) - ccall((:SCIPgetPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, Cuint), scip, dir, onlycurrentrun) + ccall( + (:SCIPgetPseudocostCount, libscip), + Cdouble, + (Ptr{SCIP}, SCIP_BRANCHDIR, Cuint), + scip, + dir, + onlycurrentrun, + ) end function SCIPgetAvgPseudocostScore(scip) @@ -8870,15 +22056,33 @@ function SCIPgetAvgPseudocostScore(scip) end function SCIPgetAvgDPseudocostScore(scip, discountfac) - ccall((:SCIPgetAvgDPseudocostScore, libscip), Cdouble, (Ptr{SCIP}, Cdouble), scip, discountfac) + ccall( + (:SCIPgetAvgDPseudocostScore, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble), + scip, + discountfac, + ) end function SCIPgetPseudocostVariance(scip, branchdir, onlycurrentrun) - ccall((:SCIPgetPseudocostVariance, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR, Cuint), scip, branchdir, onlycurrentrun) + ccall( + (:SCIPgetPseudocostVariance, libscip), + Cdouble, + (Ptr{SCIP}, SCIP_BRANCHDIR, Cuint), + scip, + branchdir, + onlycurrentrun, + ) end function SCIPgetAvgPseudocostScoreCurrentRun(scip) - ccall((:SCIPgetAvgPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetAvgPseudocostScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP},), + scip, + ) end function SCIPgetAvgConflictScore(scip) @@ -8886,23 +22090,50 @@ function SCIPgetAvgConflictScore(scip) end function SCIPgetAvgConflictScoreCurrentRun(scip) - ccall((:SCIPgetAvgConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetAvgConflictScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP},), + scip, + ) end function SCIPgetAvgConflictlengthScore(scip) - ccall((:SCIPgetAvgConflictlengthScore, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetAvgConflictlengthScore, libscip), + Cdouble, + (Ptr{SCIP},), + scip, + ) end function SCIPgetAvgConflictlengthScoreCurrentRun(scip) - ccall((:SCIPgetAvgConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetAvgConflictlengthScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP},), + scip, + ) end function SCIPgetAvgInferences(scip, dir) - ccall((:SCIPgetAvgInferences, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall( + (:SCIPgetAvgInferences, libscip), + Cdouble, + (Ptr{SCIP}, SCIP_BRANCHDIR), + scip, + dir, + ) end function SCIPgetAvgInferencesCurrentRun(scip, dir) - ccall((:SCIPgetAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall( + (:SCIPgetAvgInferencesCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, SCIP_BRANCHDIR), + scip, + dir, + ) end function SCIPgetAvgInferenceScore(scip) @@ -8910,15 +22141,32 @@ function SCIPgetAvgInferenceScore(scip) end function SCIPgetAvgInferenceScoreCurrentRun(scip) - ccall((:SCIPgetAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetAvgInferenceScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP},), + scip, + ) end function SCIPgetAvgCutoffs(scip, dir) - ccall((:SCIPgetAvgCutoffs, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall( + (:SCIPgetAvgCutoffs, libscip), + Cdouble, + (Ptr{SCIP}, SCIP_BRANCHDIR), + scip, + dir, + ) end function SCIPgetAvgCutoffsCurrentRun(scip, dir) - ccall((:SCIPgetAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, SCIP_BRANCHDIR), scip, dir) + ccall( + (:SCIPgetAvgCutoffsCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, SCIP_BRANCHDIR), + scip, + dir, + ) end function SCIPgetAvgCutoffScore(scip) @@ -8926,7 +22174,12 @@ function SCIPgetAvgCutoffScore(scip) end function SCIPgetAvgCutoffScoreCurrentRun(scip) - ccall((:SCIPgetAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetAvgCutoffScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP},), + scip, + ) end function SCIPgetAvgGMIeff(scip) @@ -8934,7 +22187,13 @@ function SCIPgetAvgGMIeff(scip) end function SCIPincAvgGMIeff(scip, gmieff) - ccall((:SCIPincAvgGMIeff, libscip), Cvoid, (Ptr{SCIP}, Cdouble), scip, gmieff) + ccall( + (:SCIPincAvgGMIeff, libscip), + Cvoid, + (Ptr{SCIP}, Cdouble), + scip, + gmieff, + ) end function SCIPgetDeterministicTime(scip) @@ -8942,227 +22201,565 @@ function SCIPgetDeterministicTime(scip) end function SCIPprintStatusStatistics(scip, file) - ccall((:SCIPprintStatusStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintStatusStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectStatusStatistics(scip, datatree) - ccall((:SCIPcollectStatusStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectStatusStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintTimingStatistics(scip, file) - ccall((:SCIPprintTimingStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintTimingStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectTimingStatistics(scip, datatree) - ccall((:SCIPcollectTimingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectTimingStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintOrigProblemStatistics(scip, file) - ccall((:SCIPprintOrigProblemStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintOrigProblemStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectOrigProblemStatistics(scip, datatree) - ccall((:SCIPcollectOrigProblemStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectOrigProblemStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintTransProblemStatistics(scip, file) - ccall((:SCIPprintTransProblemStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintTransProblemStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectTransProblemStatistics(scip, datatree) - ccall((:SCIPcollectTransProblemStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectTransProblemStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintPresolverStatistics(scip, file) - ccall((:SCIPprintPresolverStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintPresolverStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectPresolverStatistics(scip, datatree) - ccall((:SCIPcollectPresolverStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectPresolverStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintConstraintStatistics(scip, file) - ccall((:SCIPprintConstraintStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintConstraintStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectConstraintStatistics(scip, datatree) - ccall((:SCIPcollectConstraintStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectConstraintStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintConstraintTimingStatistics(scip, file) - ccall((:SCIPprintConstraintTimingStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintConstraintTimingStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectConstraintTimingStatistics(scip, datatree) - ccall((:SCIPcollectConstraintTimingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectConstraintTimingStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintPropagatorStatistics(scip, file) - ccall((:SCIPprintPropagatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintPropagatorStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectPropagatorStatistics(scip, datatree) - ccall((:SCIPcollectPropagatorStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectPropagatorStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintConflictStatistics(scip, file) - ccall((:SCIPprintConflictStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintConflictStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectConflictStatistics(scip, datatree) - ccall((:SCIPcollectConflictStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectConflictStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintSeparatorStatistics(scip, file) - ccall((:SCIPprintSeparatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintSeparatorStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectSeparatorStatistics(scip, datatree) - ccall((:SCIPcollectSeparatorStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectSeparatorStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintCutselectorStatistics(scip, file) - ccall((:SCIPprintCutselectorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintCutselectorStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectCutselectorStatistics(scip, datatree) - ccall((:SCIPcollectCutselectorStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectCutselectorStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintPricerStatistics(scip, file) - ccall((:SCIPprintPricerStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintPricerStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectPricerStatistics(scip, datatree) - ccall((:SCIPcollectPricerStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectPricerStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintBranchruleStatistics(scip, file) - ccall((:SCIPprintBranchruleStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintBranchruleStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectBranchruleStatistics(scip, datatree) - ccall((:SCIPcollectBranchruleStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectBranchruleStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintHeuristicStatistics(scip, file) - ccall((:SCIPprintHeuristicStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintHeuristicStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectHeuristicStatistics(scip, datatree) - ccall((:SCIPcollectHeuristicStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectHeuristicStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintCompressionStatistics(scip, file) - ccall((:SCIPprintCompressionStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintCompressionStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectCompressionStatistics(scip, datatree) - ccall((:SCIPcollectCompressionStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectCompressionStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintLPStatistics(scip, file) - ccall((:SCIPprintLPStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintLPStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectLPStatistics(scip, datatree) - ccall((:SCIPcollectLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectLPStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintNLPStatistics(scip, file) - ccall((:SCIPprintNLPStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintNLPStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectNLPStatistics(scip, datatree) - ccall((:SCIPcollectNLPStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectNLPStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintRelaxatorStatistics(scip, file) - ccall((:SCIPprintRelaxatorStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintRelaxatorStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectRelaxatorStatistics(scip, datatree) - ccall((:SCIPcollectRelaxatorStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectRelaxatorStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintTreeStatistics(scip, file) - ccall((:SCIPprintTreeStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintTreeStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectTreeStatistics(scip, datatree) - ccall((:SCIPcollectTreeStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectTreeStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintRootStatistics(scip, file) - ccall((:SCIPprintRootStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintRootStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectRootStatistics(scip, datatree) - ccall((:SCIPcollectRootStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectRootStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintSolutionStatistics(scip, file) - ccall((:SCIPprintSolutionStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintSolutionStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectSolutionStatistics(scip, datatree) - ccall((:SCIPcollectSolutionStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectSolutionStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintConcsolverStatistics(scip, file) - ccall((:SCIPprintConcsolverStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintConcsolverStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectConcsolverStatistics(scip, datatree) - ccall((:SCIPcollectConcsolverStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectConcsolverStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintBendersStatistics(scip, file) - ccall((:SCIPprintBendersStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintBendersStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectBendersStatistics(scip, datatree) - ccall((:SCIPcollectBendersStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectBendersStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintExpressionHandlerStatistics(scip, file) - ccall((:SCIPprintExpressionHandlerStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintExpressionHandlerStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectExpressionHandlerStatistics(scip, datatree) - ccall((:SCIPcollectExpressionHandlerStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectExpressionHandlerStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintNLPIStatistics(scip, file) - ccall((:SCIPprintNLPIStatistics, libscip), Cvoid, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintNLPIStatistics, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectNLPIStatistics(scip, datatree) - ccall((:SCIPcollectNLPIStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectNLPIStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintStatistics(scip, file) - ccall((:SCIPprintStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPprintStatisticsJson(scip, file) - ccall((:SCIPprintStatisticsJson, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintStatisticsJson, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPprintReoptStatistics(scip, file) - ccall((:SCIPprintReoptStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintReoptStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPprintBranchingStatistics(scip, file) - ccall((:SCIPprintBranchingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}), scip, file) + ccall( + (:SCIPprintBranchingStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}), + scip, + file, + ) end function SCIPcollectBranchingStatistics(scip, datatree) - ccall((:SCIPcollectBranchingStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DATATREE}), scip, datatree) + ccall( + (:SCIPcollectBranchingStatistics, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DATATREE}), + scip, + datatree, + ) end function SCIPprintDisplayLine(scip, file, verblevel, endline) - ccall((:SCIPprintDisplayLine, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, SCIP_VERBLEVEL, Cuint), scip, file, verblevel, endline) + ccall( + (:SCIPprintDisplayLine, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, SCIP_VERBLEVEL, Cuint), + scip, + file, + verblevel, + endline, + ) end function SCIPgetNImplications(scip) @@ -9177,12 +22774,69 @@ function SCIPgetPrimalDualIntegral(scip) ccall((:SCIPgetPrimalDualIntegral, libscip), Cdouble, (Ptr{SCIP},), scip) end -function SCIPincludeTable(scip, name, desc, active, tablecopy, tablefree, tableinit, tableexit, tableinitsol, tableexitsol, tableoutput, tablecollect, tabledata, position, earlieststage) - ccall((:SCIPincludeTable, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Ptr{Cvoid}, 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, tablecollect, tabledata, position, earlieststage) +function SCIPincludeTable( + scip, + name, + desc, + active, + tablecopy, + tablefree, + tableinit, + tableexit, + tableinitsol, + tableexitsol, + tableoutput, + tablecollect, + tabledata, + position, + earlieststage, +) + ccall( + (:SCIPincludeTable, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Cchar}, + Cuint, + Ptr{Cvoid}, + 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, + tablecollect, + tabledata, + position, + earlieststage, + ) end function SCIPfindTable(scip, name) - ccall((:SCIPfindTable, libscip), Ptr{SCIP_TABLE}, (Ptr{SCIP}, Ptr{Cchar}), scip, name) + ccall( + (:SCIPfindTable, libscip), + Ptr{SCIP_TABLE}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + name, + ) end function SCIPgetTables(scip) @@ -9198,39 +22852,92 @@ function SCIPgetTimeOfDay(scip) end function SCIPcreateClock(scip, clck) - ccall((:SCIPcreateClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) + ccall( + (:SCIPcreateClock, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), + scip, + clck, + ) end function SCIPcreateCPUClock(scip, clck) - ccall((:SCIPcreateCPUClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) + ccall( + (:SCIPcreateCPUClock, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), + scip, + clck, + ) end function SCIPcreateWallClock(scip, clck) - ccall((:SCIPcreateWallClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) + ccall( + (:SCIPcreateWallClock, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), + scip, + clck, + ) end function SCIPfreeClock(scip, clck) - ccall((:SCIPfreeClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), scip, clck) + ccall( + (:SCIPfreeClock, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CLOCK}}), + scip, + clck, + ) end function SCIPresetClock(scip, clck) - ccall((:SCIPresetClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) + ccall( + (:SCIPresetClock, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CLOCK}), + scip, + clck, + ) end function SCIPstartClock(scip, clck) - ccall((:SCIPstartClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) + ccall( + (:SCIPstartClock, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CLOCK}), + scip, + clck, + ) end function SCIPstopClock(scip, clck) - ccall((:SCIPstopClock, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) + ccall( + (:SCIPstopClock, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CLOCK}), + scip, + clck, + ) end function SCIPsetClockEnabled(clck, enable) - ccall((:SCIPsetClockEnabled, libscip), Cvoid, (Ptr{SCIP_CLOCK}, Cuint), clck, enable) + ccall( + (:SCIPsetClockEnabled, libscip), + Cvoid, + (Ptr{SCIP_CLOCK}, Cuint), + clck, + enable, + ) end function SCIPenableOrDisableStatisticTiming(scip) - ccall((:SCIPenableOrDisableStatisticTiming, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPenableOrDisableStatisticTiming, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPstartSolvingTime(scip) @@ -9242,11 +22949,24 @@ function SCIPstopSolvingTime(scip) end function SCIPgetClockTime(scip, clck) - ccall((:SCIPgetClockTime, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CLOCK}), scip, clck) + ccall( + (:SCIPgetClockTime, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_CLOCK}), + scip, + clck, + ) end function SCIPsetClockTime(scip, clck, sec) - ccall((:SCIPsetClockTime, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CLOCK}, Cdouble), scip, clck, sec) + ccall( + (:SCIPsetClockTime, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CLOCK}, Cdouble), + scip, + clck, + sec, + ) end function SCIPgetTotalTime(scip) @@ -9302,7 +23022,14 @@ function SCIPinRepropagation(scip) end function SCIPgetChildren(scip, children, nchildren) - ccall((:SCIPgetChildren, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, children, nchildren) + ccall( + (:SCIPgetChildren, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), + scip, + children, + nchildren, + ) end function SCIPgetNChildren(scip) @@ -9310,7 +23037,14 @@ function SCIPgetNChildren(scip) end function SCIPgetSiblings(scip, siblings, nsiblings) - ccall((:SCIPgetSiblings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, siblings, nsiblings) + ccall( + (:SCIPgetSiblings, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), + scip, + siblings, + nsiblings, + ) end function SCIPgetNSiblings(scip) @@ -9318,7 +23052,14 @@ function SCIPgetNSiblings(scip) end function SCIPgetLeaves(scip, leaves, nleaves) - ccall((:SCIPgetLeaves, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), scip, leaves, nleaves) + ccall( + (:SCIPgetLeaves, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_NODE}}}, Ptr{Cint}), + scip, + leaves, + nleaves, + ) end function SCIPgetNLeaves(scip) @@ -9357,12 +23098,45 @@ 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) +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) + ccall( + (:SCIPcutoffNode, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) end function SCIPpruneTree(scip) @@ -9370,7 +23144,13 @@ function SCIPpruneTree(scip) end function SCIPrepropagateNode(scip, node) - ccall((:SCIPrepropagateNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) + ccall( + (:SCIPrepropagateNode, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) end function SCIPgetCutoffdepth(scip) @@ -9382,207 +23162,976 @@ function SCIPgetRepropdepth(scip) end function SCIPprintNodeRootPath(scip, node, file) - ccall((:SCIPprintNodeRootPath, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Libc.FILE}), scip, node, file) + ccall( + (:SCIPprintNodeRootPath, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{Libc.FILE}), + scip, + node, + file, + ) end function SCIPsetFocusnodeLP(scip, solvelp) - ccall((:SCIPsetFocusnodeLP, libscip), Cvoid, (Ptr{SCIP}, Cuint), scip, solvelp) + ccall( + (:SCIPsetFocusnodeLP, libscip), + Cvoid, + (Ptr{SCIP}, Cuint), + scip, + solvelp, + ) end function SCIPwasNodeLastBranchParent(scip, node) - ccall((:SCIPwasNodeLastBranchParent, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_NODE}), scip, node) -end - -function SCIPvalidateSolve(scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) - ccall((:SCIPvalidateSolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, primalreference, dualreference, reftol, quiet, feasible, primalboundcheck, dualboundcheck) -end - -function SCIPvalidateSolveExact(scip, primalreference, dualreference, quiet, feasible, primalboundcheck, dualboundcheck) - ccall((:SCIPvalidateSolveExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, primalreference, dualreference, quiet, feasible, primalboundcheck, dualboundcheck) -end - -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}}, Ptr{Cchar}, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}), scip, var, name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) + ccall( + (:SCIPwasNodeLastBranchParent, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_NODE}), + scip, + node, + ) +end + +function SCIPvalidateSolve( + scip, + primalreference, + dualreference, + reftol, + quiet, + feasible, + primalboundcheck, + dualboundcheck, +) + ccall( + (:SCIPvalidateSolve, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cdouble, + Cdouble, + Cdouble, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + primalreference, + dualreference, + reftol, + quiet, + feasible, + primalboundcheck, + dualboundcheck, + ) +end + +function SCIPvalidateSolveExact( + scip, + primalreference, + dualreference, + quiet, + feasible, + primalboundcheck, + dualboundcheck, +) + ccall( + (:SCIPvalidateSolveExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + primalreference, + dualreference, + quiet, + feasible, + primalboundcheck, + dualboundcheck, + ) +end + +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}}, + Ptr{Cchar}, + Cdouble, + Cdouble, + Cdouble, + SCIP_VARTYPE, + Cuint, + Cuint, + 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}}, Ptr{Cchar}, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE), scip, var, name, lb, ub, obj, vartype) -end - -function SCIPcreateVarImpl(scip, var, name, lb, ub, obj, vartype, impltype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) - ccall((:SCIPcreateVarImpl, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cchar}, Cdouble, Cdouble, Cdouble, SCIP_VARTYPE, SCIP_IMPLINTTYPE, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}), scip, var, name, lb, ub, obj, vartype, impltype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) + ccall( + (:SCIPcreateVarBasic, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cchar}, + Cdouble, + Cdouble, + Cdouble, + SCIP_VARTYPE, + ), + scip, + var, + name, + lb, + ub, + obj, + vartype, + ) +end + +function SCIPcreateVarImpl( + scip, + var, + name, + lb, + ub, + obj, + vartype, + impltype, + initial, + removable, + vardelorig, + vartrans, + vardeltrans, + varcopy, + vardata, +) + ccall( + (:SCIPcreateVarImpl, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cchar}, + Cdouble, + Cdouble, + Cdouble, + SCIP_VARTYPE, + SCIP_IMPLINTTYPE, + Cuint, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_VARDATA}, + ), + scip, + var, + name, + lb, + ub, + obj, + vartype, + impltype, + initial, + removable, + vardelorig, + vartrans, + vardeltrans, + varcopy, + vardata, + ) end function SCIPaddVarExactData(scip, var, lb, ub, obj) - ccall((:SCIPaddVarExactData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), scip, var, lb, ub, obj) + ccall( + (:SCIPaddVarExactData, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + ), + scip, + var, + lb, + ub, + obj, + ) end function SCIPwriteVarName(scip, file, var, type) - ccall((:SCIPwriteVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_VAR}, Cuint), scip, file, var, type) + ccall( + (:SCIPwriteVarName, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_VAR}, Cuint), + scip, + file, + var, + type, + ) end function SCIPwriteVarsList(scip, file, vars, nvars, type, delimiter) - ccall((:SCIPwriteVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cchar), scip, file, vars, nvars, type, delimiter) + ccall( + (:SCIPwriteVarsList, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cchar), + scip, + file, + vars, + nvars, + type, + delimiter, + ) end function SCIPwriteVarsLinearsum(scip, file, vars, vals, nvars, type) - ccall((:SCIPwriteVarsLinearsum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint), 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{Libc.FILE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Cuint), 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}}, Ptr{Cchar}, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_VARDATA}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), scip, var, str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) + ccall( + (:SCIPwriteVarsLinearsum, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cint, + Cuint, + ), + 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{Libc.FILE}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Ptr{Cdouble}}, + Ptr{Cdouble}, + Ptr{Cint}, + Cint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + Cuint, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_VARDATA}, + Ptr{Ptr{Cchar}}, + Ptr{Cuint}, + ), + 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}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{Cchar}}), scip, str, var, endptr) -end - -function SCIPparseVarsList(scip, str, vars, nvars, varssize, requiredsize, endptr, delimiter, success) - ccall((:SCIPparseVarsList, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Ptr{Cchar}}, Cchar, Ptr{Cuint}), 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}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) -end - -function SCIPparseVarsLinearsumExact(scip, str, vars, vals, nvars, varssize, requiredsize, endptr, success) - ccall((:SCIPparseVarsLinearsumExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), 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}, Ptr{Cchar}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), scip, str, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials, endptr, success) -end - -function SCIPfreeParseVarsPolynomialDataExact(scip, monomialvars, monomialcoefs, nmonomials) - ccall((:SCIPfreeParseVarsPolynomialDataExact, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), scip, monomialvars, monomialcoefs, nmonomials) -end - -function SCIPparseVarsPolynomialExact(scip, str, monomialvars, monomialcoefs, nmonomials, endptr, success) - ccall((:SCIPparseVarsPolynomialExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Cint}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), scip, str, monomialvars, monomialcoefs, nmonomials, endptr, success) -end - -function SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials) - ccall((:SCIPfreeParseVarsPolynomialData, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Ptr{Ptr{Ptr{Cdouble}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Cint), scip, monomialvars, monomialexps, monomialcoefs, monomialnvars, nmonomials) + ccall( + (:SCIPparseVarName, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{Cchar}}), + scip, + str, + var, + endptr, + ) +end + +function SCIPparseVarsList( + scip, + str, + vars, + nvars, + varssize, + requiredsize, + endptr, + delimiter, + success, +) + ccall( + (:SCIPparseVarsList, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cint}, + Cint, + Ptr{Cint}, + Ptr{Ptr{Cchar}}, + Cchar, + Ptr{Cuint}, + ), + 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}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cint}, + Cint, + Ptr{Cint}, + Ptr{Ptr{Cchar}}, + Ptr{Cuint}, + ), + scip, + str, + vars, + vals, + nvars, + varssize, + requiredsize, + endptr, + success, + ) +end + +function SCIPparseVarsLinearsumExact( + scip, + str, + vars, + vals, + nvars, + varssize, + requiredsize, + endptr, + success, +) + ccall( + (:SCIPparseVarsLinearsumExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{Cint}, + Cint, + Ptr{Cint}, + Ptr{Ptr{Cchar}}, + Ptr{Cuint}, + ), + 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}, + Ptr{Cchar}, + Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, + Ptr{Ptr{Ptr{Cdouble}}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + Ptr{Ptr{Cchar}}, + Ptr{Cuint}, + ), + scip, + str, + monomialvars, + monomialexps, + monomialcoefs, + monomialnvars, + nmonomials, + endptr, + success, + ) +end + +function SCIPfreeParseVarsPolynomialDataExact( + scip, + monomialvars, + monomialcoefs, + nmonomials, +) + ccall( + (:SCIPfreeParseVarsPolynomialDataExact, libscip), + Cvoid, + ( + Ptr{SCIP}, + Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, + Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, + Cint, + ), + scip, + monomialvars, + monomialcoefs, + nmonomials, + ) +end + +function SCIPparseVarsPolynomialExact( + scip, + str, + monomialvars, + monomialcoefs, + nmonomials, + endptr, + success, +) + ccall( + (:SCIPparseVarsPolynomialExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cchar}, + Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, + Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, + Ptr{Cint}, + Ptr{Ptr{Cchar}}, + Ptr{Cuint}, + ), + scip, + str, + monomialvars, + monomialcoefs, + 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) + ccall( + (:SCIPcaptureVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPreleaseVar(scip, var) - ccall((:SCIPreleaseVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}), scip, var) + ccall( + (:SCIPreleaseVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}), + scip, + var, + ) end function SCIPchgVarName(scip, var, name) - ccall((:SCIPchgVarName, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cchar}), scip, var, name) + ccall( + (:SCIPchgVarName, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Cchar}), + scip, + var, + name, + ) end function SCIPtransformVar(scip, var, transvar) - ccall((:SCIPtransformVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) + ccall( + (:SCIPtransformVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), + scip, + var, + transvar, + ) end function SCIPtransformVars(scip, nvars, vars, transvars) - ccall((:SCIPtransformVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) + ccall( + (:SCIPtransformVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), + scip, + nvars, + vars, + transvars, + ) end function SCIPgetTransformedVar(scip, var, transvar) - ccall((:SCIPgetTransformedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, transvar) + ccall( + (:SCIPgetTransformedVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), + scip, + var, + transvar, + ) end function SCIPgetTransformedVars(scip, nvars, vars, transvars) - ccall((:SCIPgetTransformedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, transvars) + ccall( + (:SCIPgetTransformedVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), + scip, + nvars, + vars, + transvars, + ) end function SCIPgetNegatedVar(scip, var, negvar) - ccall((:SCIPgetNegatedVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), scip, var, negvar) + ccall( + (:SCIPgetNegatedVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}), + scip, + var, + negvar, + ) end function SCIPgetNegatedVars(scip, nvars, vars, negvars) - ccall((:SCIPgetNegatedVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), scip, nvars, vars, negvars) + ccall( + (:SCIPgetNegatedVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}), + scip, + nvars, + vars, + negvars, + ) end function SCIPgetBinvarRepresentative(scip, var, repvar, negated) - ccall((:SCIPgetBinvarRepresentative, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), scip, var, repvar, negated) + ccall( + (:SCIPgetBinvarRepresentative, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), + 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{Cuint}), scip, nvars, vars, repvars, negated) + ccall( + (:SCIPgetBinvarRepresentatives, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), + 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) - ccall((:SCIPgetProbvarLinearSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cdouble}, Ptr{Cint}), scip, vars, scalars, nvars, varssize, constant, requiredsize) + ccall( + (:SCIPflattenVarAggregationGraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) +end + +function SCIPgetProbvarLinearSum( + scip, + vars, + scalars, + nvars, + varssize, + constant, + requiredsize, +) + ccall( + (:SCIPgetProbvarLinearSum, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cint}, + Cint, + Ptr{Cdouble}, + Ptr{Cint}, + ), + scip, + vars, + scalars, + nvars, + varssize, + constant, + requiredsize, + ) end function SCIPgetProbvarSum(scip, var, scalar, constant) - ccall((:SCIPgetProbvarSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), scip, var, scalar, constant) + ccall( + (:SCIPgetProbvarSum, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), + scip, + var, + scalar, + constant, + ) end function SCIPgetProbvarSumExact(scip, var, scalar, constant) - ccall((:SCIPgetProbvarSumExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), scip, var, scalar, constant) + ccall( + (:SCIPgetProbvarSumExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + scip, + var, + scalar, + constant, + ) end function SCIPgetActiveVars(scip, vars, nvars, varssize, requiredsize) - ccall((:SCIPgetActiveVars, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}), scip, vars, nvars, varssize, requiredsize) + ccall( + (:SCIPgetActiveVars, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Ptr{Cint}), + scip, + vars, + nvars, + varssize, + requiredsize, + ) end function SCIPgetVarRedcost(scip, var) - ccall((:SCIPgetVarRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarRedcost, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarImplRedcost(scip, var, varfixing) - ccall((:SCIPgetVarImplRedcost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cuint), scip, var, varfixing) + ccall( + (:SCIPgetVarImplRedcost, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cuint), + scip, + var, + varfixing, + ) end function SCIPgetVarFarkasCoef(scip, var) - ccall((:SCIPgetVarFarkasCoef, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarFarkasCoef, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarLbAtIndex(scip, var, bdchgidx, after) - ccall((:SCIPgetVarLbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), scip, var, bdchgidx, after) + ccall( + (:SCIPgetVarLbAtIndex, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), + scip, + var, + bdchgidx, + after, + ) end function SCIPgetVarUbAtIndex(scip, var, bdchgidx, after) - ccall((:SCIPgetVarUbAtIndex, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), scip, var, bdchgidx, after) + ccall( + (:SCIPgetVarUbAtIndex, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), + 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}, Cuint), scip, var, boundtype, bdchgidx, after) + ccall( + (:SCIPgetVarBdAtIndex, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cuint), + scip, + var, + boundtype, + bdchgidx, + after, + ) end function SCIPgetVarWasFixedAtIndex(scip, var, bdchgidx, after) - ccall((:SCIPgetVarWasFixedAtIndex, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), scip, var, bdchgidx, after) + ccall( + (:SCIPgetVarWasFixedAtIndex, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), + scip, + var, + bdchgidx, + after, + ) end function SCIPgetVarSol(scip, var) - ccall((:SCIPgetVarSol, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarSol, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarSols(scip, nvars, vars, vals) - ccall((:SCIPgetVarSols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, nvars, vars, vals) + ccall( + (:SCIPgetVarSols, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), + scip, + nvars, + vars, + vals, + ) end function SCIPclearRelaxSolVals(scip, relax) - ccall((:SCIPclearRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}), scip, relax) + ccall( + (:SCIPclearRelaxSolVals, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}), + scip, + relax, + ) end function SCIPsetRelaxSolVal(scip, relax, var, val) - ccall((:SCIPsetRelaxSolVal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{SCIP_VAR}, Cdouble), scip, relax, var, val) + ccall( + (:SCIPsetRelaxSolVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{SCIP_VAR}, Cdouble), + scip, + relax, + var, + val, + ) end function SCIPsetRelaxSolVals(scip, relax, nvars, vars, vals, includeslp) - ccall((:SCIPsetRelaxSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cuint), scip, relax, nvars, vars, vals, includeslp) + ccall( + (:SCIPsetRelaxSolVals, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_RELAX}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cuint, + ), + scip, + relax, + nvars, + vars, + vals, + includeslp, + ) end function SCIPsetRelaxSolValsSol(scip, relax, sol, includeslp) - ccall((:SCIPsetRelaxSolValsSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{SCIP_SOL}, Cuint), scip, relax, sol, includeslp) + ccall( + (:SCIPsetRelaxSolValsSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Ptr{SCIP_SOL}, Cuint), + scip, + relax, + sol, + includeslp, + ) end function SCIPisRelaxSolValid(scip) @@ -9590,7 +24139,14 @@ function SCIPisRelaxSolValid(scip) end function SCIPmarkRelaxSolValid(scip, relax, includeslp) - ccall((:SCIPmarkRelaxSolValid, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cuint), scip, relax, includeslp) + ccall( + (:SCIPmarkRelaxSolValid, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_RELAX}, Cuint), + scip, + relax, + includeslp, + ) end function SCIPmarkRelaxSolInvalid(scip) @@ -9598,7 +24154,13 @@ function SCIPmarkRelaxSolInvalid(scip) end function SCIPgetRelaxSolVal(scip, var) - ccall((:SCIPgetRelaxSolVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetRelaxSolVal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetRelaxSolObj(scip) @@ -9606,283 +24168,1395 @@ function SCIPgetRelaxSolObj(scip) end function SCIPisStrongbranchDownFirst(scip, var) - ccall((:SCIPisStrongbranchDownFirst, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPisStrongbranchDownFirst, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPstartStrongbranch(scip, enablepropagation) - ccall((:SCIPstartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, enablepropagation) + ccall( + (:SCIPstartStrongbranch, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint), + scip, + enablepropagation, + ) end function SCIPendStrongbranch(scip) ccall((:SCIPendStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPgetVarStrongbranchFrac(scip, var, itlim, idempotent, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) - ccall((:SCIPgetVarStrongbranchFrac, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, var, itlim, idempotent, 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{Cuint}, Ptr{Cuint}, Ptr{Clonglong}, Ptr{Clonglong}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, 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, idempotent, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) - ccall((:SCIPgetVarStrongbranchInt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, var, itlim, idempotent, 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, vars, nvars, itlim, down, up, downvalid, upvalid, downinf, upinf, downconflict, upconflict, lperror) +function SCIPgetVarStrongbranchFrac( + scip, + var, + itlim, + idempotent, + down, + up, + downvalid, + upvalid, + downinf, + upinf, + downconflict, + upconflict, + lperror, +) + ccall( + (:SCIPgetVarStrongbranchFrac, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Cint, + Cuint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + var, + itlim, + idempotent, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Clonglong}, + Ptr{Clonglong}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + 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, + idempotent, + down, + up, + downvalid, + upvalid, + downinf, + upinf, + downconflict, + upconflict, + lperror, +) + ccall( + (:SCIPgetVarStrongbranchInt, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Cint, + Cuint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + var, + itlim, + idempotent, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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{Cuint}, Ptr{Cuint}, 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, Cuint, Cuint, Clonglong, Cint), scip, var, lpobjval, primsol, down, up, downvalid, upvalid, iter, itlim) + 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{Cuint}, + Ptr{Cuint}, + 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, + Cuint, + Cuint, + 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{Cuint}, Ptr{Cuint}), scip, foundsol, cutoff) + ccall( + (:SCIPtryStrongbranchLPSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}, Ptr{Cuint}), + scip, + foundsol, + cutoff, + ) end function SCIPgetVarStrongbranchNode(scip, var) - ccall((:SCIPgetVarStrongbranchNode, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarStrongbranchNode, libscip), + Clonglong, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarStrongbranchLPAge(scip, var) - ccall((:SCIPgetVarStrongbranchLPAge, libscip), Clonglong, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarStrongbranchLPAge, libscip), + Clonglong, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarNStrongbranchs(scip, var) - ccall((:SCIPgetVarNStrongbranchs, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarNStrongbranchs, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPaddVarLocksType(scip, var, locktype, nlocksdown, nlocksup) - ccall((:SCIPaddVarLocksType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_LOCKTYPE, Cint, Cint), scip, var, locktype, nlocksdown, nlocksup) + ccall( + (:SCIPaddVarLocksType, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_LOCKTYPE, Cint, Cint), + scip, + var, + locktype, + nlocksdown, + nlocksup, + ) end function SCIPaddVarLocks(scip, var, nlocksdown, nlocksup) - ccall((:SCIPaddVarLocks, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cint), scip, var, nlocksdown, nlocksup) + ccall( + (:SCIPaddVarLocks, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Cint), + scip, + var, + nlocksdown, + nlocksup, + ) end function SCIPlockVarCons(scip, var, cons, lockdown, lockup) - ccall((:SCIPlockVarCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint), scip, var, cons, lockdown, lockup) + ccall( + (:SCIPlockVarCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint), + 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}, Cuint, Cuint), scip, var, cons, lockdown, lockup) + ccall( + (:SCIPunlockVarCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint), + scip, + var, + cons, + lockdown, + lockup, + ) end function SCIPchgVarObj(scip, var, newobj) - ccall((:SCIPchgVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newobj) + ccall( + (:SCIPchgVarObj, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newobj, + ) end function SCIPaddVarObj(scip, var, addobj) - ccall((:SCIPaddVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addobj) + ccall( + (:SCIPaddVarObj, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + addobj, + ) end function SCIPadjustedVarLb(scip, var, lb) - ccall((:SCIPadjustedVarLb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lb) + ccall( + (:SCIPadjustedVarLb, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + lb, + ) end function SCIPadjustedVarLbExactFloat(scip, var, lb) - ccall((:SCIPadjustedVarLbExactFloat, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lb) + ccall( + (:SCIPadjustedVarLbExactFloat, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + lb, + ) end function SCIPadjustedVarUb(scip, var, ub) - ccall((:SCIPadjustedVarUb, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, ub) + ccall( + (:SCIPadjustedVarUb, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + ub, + ) end function SCIPadjustedVarUbExactFloat(scip, var, ub) - ccall((:SCIPadjustedVarUbExactFloat, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, ub) + ccall( + (:SCIPadjustedVarUbExactFloat, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + ub, + ) end function SCIPchgVarLb(scip, var, newbound) - ccall((:SCIPchgVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall( + (:SCIPchgVarLb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newbound, + ) end function SCIPchgVarLbExact(scip, var, newbound) - ccall((:SCIPchgVarLbExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) + ccall( + (:SCIPchgVarLbExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + newbound, + ) end function SCIPchgVarUb(scip, var, newbound) - ccall((:SCIPchgVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall( + (:SCIPchgVarUb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newbound, + ) end function SCIPchgVarUbExact(scip, var, newbound) - ccall((:SCIPchgVarUbExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) + ccall( + (:SCIPchgVarUbExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + newbound, + ) end function SCIPchgVarLbNode(scip, node, var, newbound) - ccall((:SCIPchgVarLbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) + ccall( + (:SCIPchgVarLbNode, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), + scip, + node, + var, + newbound, + ) end function SCIPchgVarUbNode(scip, node, var, newbound) - ccall((:SCIPchgVarUbNode, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), scip, node, var, newbound) + ccall( + (:SCIPchgVarUbNode, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_NODE}, Ptr{SCIP_VAR}, Cdouble), + scip, + node, + var, + newbound, + ) end function SCIPchgVarLbGlobal(scip, var, newbound) - ccall((:SCIPchgVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall( + (:SCIPchgVarLbGlobal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newbound, + ) end function SCIPchgVarUbGlobal(scip, var, newbound) - ccall((:SCIPchgVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, newbound) + ccall( + (:SCIPchgVarUbGlobal, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + newbound, + ) end function SCIPchgVarLbLazy(scip, var, lazylb) - ccall((:SCIPchgVarLbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazylb) + ccall( + (:SCIPchgVarLbLazy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + lazylb, + ) end function SCIPchgVarUbLazy(scip, var, lazyub) - ccall((:SCIPchgVarUbLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, lazyub) + ccall( + (:SCIPchgVarUbLazy, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + lazyub, + ) end function SCIPtightenVarLb(scip, var, newbound, force, infeasible, tightened) - ccall((:SCIPtightenVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, force, infeasible, tightened) + ccall( + (:SCIPtightenVarLb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}), + scip, + var, + newbound, + force, + infeasible, + tightened, + ) end function SCIPtightenVarLbExact(scip, var, newbound, infeasible, tightened) - ccall((:SCIPtightenVarLbExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, infeasible, tightened) + ccall( + (:SCIPtightenVarLbExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), + scip, + var, + newbound, + infeasible, + tightened, + ) end function SCIPtightenVarUb(scip, var, newbound, force, infeasible, tightened) - ccall((:SCIPtightenVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, force, infeasible, tightened) + ccall( + (:SCIPtightenVarUb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cuint, Ptr{Cuint}, Ptr{Cuint}), + scip, + var, + newbound, + force, + infeasible, + tightened, + ) end function SCIPtightenVarUbExact(scip, var, newbound, infeasible, tightened) - ccall((:SCIPtightenVarUbExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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}, Cuint, Ptr{SCIP_CONS}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, var, fixedval, infercons, inferinfo, infeasible, tightened) -end - -function SCIPinferVarUbConsExact(scip, var, newbound, infercons, inferinfo, infeasible, tightened) - ccall((:SCIPinferVarUbConsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_CONS}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, infercons, inferinfo, infeasible, tightened) -end - -function SCIPinferVarLbConsExact(scip, var, newbound, infercons, inferinfo, infeasible, tightened) - ccall((:SCIPinferVarLbConsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_CONS}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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}, Cuint, Ptr{SCIP_PROP}, Cint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), scip, var, newbound, force, infeasible, tightened) + ccall( + (:SCIPtightenVarUbExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), + scip, + var, + newbound, + 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, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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}, + Cuint, + Ptr{SCIP_CONS}, + Cint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + var, + fixedval, + infercons, + inferinfo, + infeasible, + tightened, + ) +end + +function SCIPinferVarUbConsExact( + scip, + var, + newbound, + infercons, + inferinfo, + infeasible, + tightened, +) + ccall( + (:SCIPinferVarUbConsExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_CONS}, + Cint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + var, + newbound, + infercons, + inferinfo, + infeasible, + tightened, + ) +end + +function SCIPinferVarLbConsExact( + scip, + var, + newbound, + infercons, + inferinfo, + infeasible, + tightened, +) + ccall( + (:SCIPinferVarLbConsExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_CONS}, + Cint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + var, + newbound, + 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, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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}, + Cuint, + Ptr{SCIP_PROP}, + Cint, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), + 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, Cuint, Ptr{Cuint}, Ptr{Cuint}), + scip, + var, + newbound, + force, + infeasible, + tightened, + ) end function SCIPcomputeVarLbGlobal(scip, var) - ccall((:SCIPcomputeVarLbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPcomputeVarLbGlobal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPcomputeVarUbGlobal(scip, var) - ccall((:SCIPcomputeVarUbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPcomputeVarUbGlobal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPcomputeVarLbLocal(scip, var) - ccall((:SCIPcomputeVarLbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPcomputeVarLbLocal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPcomputeVarLbLocalExact(scip, var, result) - ccall((:SCIPcomputeVarLbLocalExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, result) + ccall( + (:SCIPcomputeVarLbLocalExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + result, + ) end function SCIPcomputeVarUbLocal(scip, var) - ccall((:SCIPcomputeVarUbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPcomputeVarUbLocal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPcomputeVarUbLocalExact(scip, var, result) - ccall((:SCIPcomputeVarUbLocalExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, result) + ccall( + (:SCIPcomputeVarUbLocalExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + result, + ) end function SCIPgetVarMultaggrLbGlobal(scip, var) - ccall((:SCIPgetVarMultaggrLbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarMultaggrLbGlobal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarMultaggrUbGlobal(scip, var) - ccall((:SCIPgetVarMultaggrUbGlobal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarMultaggrUbGlobal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarMultaggrLbLocal(scip, var) - ccall((:SCIPgetVarMultaggrLbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarMultaggrLbLocal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarMultaggrUbLocal(scip, var) - ccall((:SCIPgetVarMultaggrUbLocal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarMultaggrUbLocal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarClosestVlb(scip, var, sol, closestvlb, closestvlbidx) - ccall((:SCIPgetVarClosestVlb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvlb, closestvlbidx) + ccall( + (:SCIPgetVarClosestVlb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), + scip, + var, + sol, + closestvlb, + closestvlbidx, + ) end function SCIPgetVarClosestVub(scip, var, sol, closestvub, closestvubidx) - ccall((:SCIPgetVarClosestVub, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cint}), scip, var, sol, closestvub, closestvubidx) -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{Cuint}, 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{Cuint}, 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}, Cuint, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Cdouble, Ptr{Cuint}, 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{Cuint}, Cint, Cuint, Ptr{Cuint}, Ptr{Cint}), scip, vars, values, nvars, isequation, infeasible, nbdchgs) -end - -function SCIPcalcCliquePartition(scip, vars, nvars, probtoidxmap, probtoidxmapsize, cliquepartition, ncliques) - ccall((:SCIPcalcCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, probtoidxmap, probtoidxmapsize, cliquepartition, ncliques) -end - -function SCIPcalcNegatedCliquePartition(scip, vars, nvars, probtoidxmap, probtoidxmapsize, cliquepartition, ncliques) - ccall((:SCIPcalcNegatedCliquePartition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, vars, nvars, probtoidxmap, probtoidxmapsize, cliquepartition, ncliques) + 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{Cuint}, + 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{Cuint}, + 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}, + Cuint, + Ptr{SCIP_VAR}, + SCIP_BOUNDTYPE, + Cdouble, + Ptr{Cuint}, + 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{Cuint}, + Cint, + Cuint, + Ptr{Cuint}, + Ptr{Cint}, + ), + scip, + vars, + values, + nvars, + isequation, + infeasible, + nbdchgs, + ) +end + +function SCIPcalcCliquePartition( + scip, + vars, + nvars, + probtoidxmap, + probtoidxmapsize, + cliquepartition, + ncliques, +) + ccall( + (:SCIPcalcCliquePartition, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + vars, + nvars, + probtoidxmap, + probtoidxmapsize, + cliquepartition, + ncliques, + ) +end + +function SCIPcalcNegatedCliquePartition( + scip, + vars, + nvars, + probtoidxmap, + probtoidxmapsize, + cliquepartition, + ncliques, +) + ccall( + (:SCIPcalcNegatedCliquePartition, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + vars, + nvars, + probtoidxmap, + probtoidxmapsize, + cliquepartition, + ncliques, + ) end function SCIPcleanupCliques(scip, infeasible) - ccall((:SCIPcleanupCliques, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, infeasible) + ccall( + (:SCIPcleanupCliques, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}), + scip, + infeasible, + ) end function SCIPgetNCliques(scip) @@ -9897,76 +25571,315 @@ 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), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint, Cuint), scip, var1, value1, var2, value2, regardimplics) +function SCIPhaveVarsCommonClique( + scip, + var1, + value1, + var2, + value2, + regardimplics, +) + ccall( + (:SCIPhaveVarsCommonClique, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint, Cuint), + scip, + var1, + value1, + var2, + value2, + regardimplics, + ) end function SCIPwriteCliqueGraph(scip, fname, writenodeweights) - ccall((:SCIPwriteCliqueGraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Cuint), scip, fname, writenodeweights) + ccall( + (:SCIPwriteCliqueGraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Cuint), + scip, + fname, + writenodeweights, + ) end function SCIPremoveVarFromGlobalStructures(scip, var) - ccall((:SCIPremoveVarFromGlobalStructures, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPremoveVarFromGlobalStructures, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPchgVarBranchFactor(scip, var, branchfactor) - ccall((:SCIPchgVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, branchfactor) + ccall( + (:SCIPchgVarBranchFactor, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + branchfactor, + ) end function SCIPscaleVarBranchFactor(scip, var, scale) - ccall((:SCIPscaleVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, scale) + ccall( + (:SCIPscaleVarBranchFactor, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + scale, + ) end function SCIPaddVarBranchFactor(scip, var, addfactor) - ccall((:SCIPaddVarBranchFactor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, addfactor) + ccall( + (:SCIPaddVarBranchFactor, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + addfactor, + ) end function SCIPchgVarBranchPriority(scip, var, branchpriority) - ccall((:SCIPchgVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) + ccall( + (:SCIPchgVarBranchPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), + scip, + var, + branchpriority, + ) end function SCIPupdateVarBranchPriority(scip, var, branchpriority) - ccall((:SCIPupdateVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, branchpriority) + ccall( + (:SCIPupdateVarBranchPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), + scip, + var, + branchpriority, + ) end function SCIPaddVarBranchPriority(scip, var, addpriority) - ccall((:SCIPaddVarBranchPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), scip, var, addpriority) + ccall( + (:SCIPaddVarBranchPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint), + scip, + var, + addpriority, + ) end function SCIPchgVarBranchDirection(scip, var, branchdirection) - ccall((:SCIPchgVarBranchDirection, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, branchdirection) + ccall( + (:SCIPchgVarBranchDirection, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + branchdirection, + ) end function SCIPchgVarType(scip, var, vartype, infeasible) - ccall((:SCIPchgVarType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_VARTYPE, Ptr{Cuint}), scip, var, vartype, infeasible) + ccall( + (:SCIPchgVarType, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_VARTYPE, Ptr{Cuint}), + scip, + var, + vartype, + infeasible, + ) end function SCIPchgVarImplType(scip, var, impltype, infeasible) - ccall((:SCIPchgVarImplType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_IMPLINTTYPE, Ptr{Cuint}), scip, var, impltype, infeasible) + ccall( + (:SCIPchgVarImplType, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_IMPLINTTYPE, Ptr{Cuint}), + scip, + var, + impltype, + infeasible, + ) end function SCIPfixVar(scip, var, fixedval, infeasible, fixed) - ccall((:SCIPfixVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{Cuint}, Ptr{Cuint}), scip, var, fixedval, infeasible, fixed) + ccall( + (:SCIPfixVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{Cuint}, Ptr{Cuint}), + scip, + var, + fixedval, + infeasible, + fixed, + ) end function SCIPfixVarExact(scip, var, fixedval, infeasible, fixed) - ccall((:SCIPfixVarExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}), scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) -end - -function SCIPaggregateVarsExact(scip, varx, vary, scalarx, scalary, rhs, infeasible, redundant, aggregated) - ccall((:SCIPaggregateVarsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, Ptr{Cuint}), scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) -end - -function SCIPmultiaggregateVarExact(scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) - ccall((:SCIPmultiaggregateVarExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), scip, var, naggvars, aggvars, scalars, constant, infeasible, aggregated) + ccall( + (:SCIPfixVarExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{Cuint}, Ptr{Cuint}), + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + varx, + vary, + scalarx, + scalary, + rhs, + infeasible, + redundant, + aggregated, + ) +end + +function SCIPaggregateVarsExact( + scip, + varx, + vary, + scalarx, + scalary, + rhs, + infeasible, + redundant, + aggregated, +) + ccall( + (:SCIPaggregateVarsExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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{Cuint}, + Ptr{Cuint}, + ), + scip, + var, + naggvars, + aggvars, + scalars, + constant, + infeasible, + aggregated, + ) +end + +function SCIPmultiaggregateVarExact( + scip, + var, + naggvars, + aggvars, + scalars, + constant, + infeasible, + aggregated, +) + ccall( + (:SCIPmultiaggregateVarExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{SCIP_RATIONAL}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + var, + naggvars, + aggvars, + scalars, + constant, + infeasible, + aggregated, + ) end function SCIPdoNotAggr(scip) @@ -9978,15 +25891,34 @@ function SCIPdoNotMultaggr(scip) end function SCIPdoNotAggrVar(scip, var) - ccall((:SCIPdoNotAggrVar, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPdoNotAggrVar, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPdoNotMultaggrVar(scip, var) - ccall((:SCIPdoNotMultaggrVar, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPdoNotMultaggrVar, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPisVarAggrCoefAcceptable(scip, var, scalar) - ccall((:SCIPisVarAggrCoefAcceptable, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, scalar) + ccall( + (:SCIPisVarAggrCoefAcceptable, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + scalar, + ) end function SCIPallowStrongDualReds(scip) @@ -9998,11 +25930,23 @@ function SCIPallowWeakDualReds(scip) end function SCIPmarkDoNotAggrVar(scip, var) - ccall((:SCIPmarkDoNotAggrVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPmarkDoNotAggrVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPmarkDoNotMultaggrVar(scip, var) - ccall((:SCIPmarkDoNotMultaggrVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPmarkDoNotMultaggrVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPenableVarHistory(scip) @@ -10014,451 +25958,1864 @@ function SCIPdisableVarHistory(scip) end function SCIPupdateVarPseudocost(scip, var, solvaldelta, objdelta, weight) - ccall((:SCIPupdateVarPseudocost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, var, solvaldelta, objdelta, weight) + ccall( + (:SCIPupdateVarPseudocost, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), + scip, + var, + solvaldelta, + objdelta, + weight, + ) end function SCIPupdateVarAncPseudocost(scip, var, solvaldelta, objdelta, weight) - ccall((:SCIPupdateVarAncPseudocost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), scip, var, solvaldelta, objdelta, weight) + ccall( + (:SCIPupdateVarAncPseudocost, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), + scip, + var, + solvaldelta, + objdelta, + weight, + ) end function SCIPgetVarPseudocostVal(scip, var, solvaldelta) - ccall((:SCIPgetVarPseudocostVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) + ccall( + (:SCIPgetVarPseudocostVal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + solvaldelta, + ) end function SCIPgetVarAncPseudocostVal(scip, var, solvaldelta) - ccall((:SCIPgetVarAncPseudocostVal, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) + ccall( + (:SCIPgetVarAncPseudocostVal, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + solvaldelta, + ) end function SCIPgetVarPseudocostValCurrentRun(scip, var, solvaldelta) - ccall((:SCIPgetVarPseudocostValCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solvaldelta) + ccall( + (:SCIPgetVarPseudocostValCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + solvaldelta, + ) end function SCIPgetVarPseudocost(scip, var, dir) - ccall((:SCIPgetVarPseudocost, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarPseudocost, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarPseudocostCurrentRun(scip, var, dir) - ccall((:SCIPgetVarPseudocostCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarPseudocostCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarPseudocostCount(scip, var, dir) - ccall((:SCIPgetVarPseudocostCount, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarPseudocostCount, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarPseudocostCountCurrentRun(scip, var, dir) - ccall((:SCIPgetVarPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarPseudocostCountCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarAncPseudocostCountCurrentRun(scip, var, dir) - ccall((:SCIPgetVarAncPseudocostCountCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarAncPseudocostCountCurrentRun, 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, Cuint), scip, var, dir, onlycurrentrun) -end - -function SCIPcalculatePscostConfidenceBound(scip, var, dir, onlycurrentrun, clevel) - ccall((:SCIPcalculatePscostConfidenceBound, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cuint, SCIP_CONFIDENCELEVEL), scip, var, dir, onlycurrentrun, clevel) -end - -function SCIPsignificantVarPscostDifference(scip, varx, fracx, vary, fracy, dir, clevel, onesided) - ccall((:SCIPsignificantVarPscostDifference, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Ptr{SCIP_VAR}, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL, Cuint), scip, varx, fracx, vary, fracy, dir, clevel, onesided) -end - -function SCIPpscostThresholdProbabilityTest(scip, var, frac, threshold, dir, clevel) - ccall((:SCIPpscostThresholdProbabilityTest, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, SCIP_BRANCHDIR, SCIP_CONFIDENCELEVEL), scip, var, frac, threshold, dir, clevel) + ccall( + (:SCIPgetVarPseudocostVariance, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cuint), + scip, + var, + dir, + onlycurrentrun, + ) +end + +function SCIPcalculatePscostConfidenceBound( + scip, + var, + dir, + onlycurrentrun, + clevel, +) + ccall( + (:SCIPcalculatePscostConfidenceBound, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cuint, SCIP_CONFIDENCELEVEL), + scip, + var, + dir, + onlycurrentrun, + clevel, + ) +end + +function SCIPsignificantVarPscostDifference( + scip, + varx, + fracx, + vary, + fracy, + dir, + clevel, + onesided, +) + ccall( + (:SCIPsignificantVarPscostDifference, libscip), + Cuint, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Cdouble, + Ptr{SCIP_VAR}, + Cdouble, + SCIP_BRANCHDIR, + SCIP_CONFIDENCELEVEL, + Cuint, + ), + scip, + varx, + fracx, + vary, + fracy, + dir, + clevel, + onesided, + ) +end + +function SCIPpscostThresholdProbabilityTest( + scip, + var, + frac, + threshold, + dir, + clevel, +) + ccall( + (:SCIPpscostThresholdProbabilityTest, libscip), + Cuint, + ( + 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), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, SCIP_CONFIDENCELEVEL), scip, var, threshold, clevel) + ccall( + (:SCIPisVarPscostRelerrorReliable, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, SCIP_CONFIDENCELEVEL), + scip, + var, + threshold, + clevel, + ) end function SCIPgetVarPseudocostScore(scip, var, solval) - ccall((:SCIPgetVarPseudocostScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) + ccall( + (:SCIPgetVarPseudocostScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + solval, + ) end function SCIPgetVarDPseudocostScore(scip, var, solval, discountfac) - ccall((:SCIPgetVarDPseudocostScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), scip, var, solval, discountfac) + ccall( + (:SCIPgetVarDPseudocostScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + scip, + var, + solval, + discountfac, + ) end function SCIPgetVarPseudocostScoreCurrentRun(scip, var, solval) - ccall((:SCIPgetVarPseudocostScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, solval) + ccall( + (:SCIPgetVarPseudocostScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + solval, + ) end function SCIPgetVarVSIDS(scip, var, dir) - ccall((:SCIPgetVarVSIDS, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarVSIDS, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarVSIDSCurrentRun(scip, var, dir) - ccall((:SCIPgetVarVSIDSCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarVSIDSCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarConflictScore(scip, var) - ccall((:SCIPgetVarConflictScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarConflictScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarConflictScoreCurrentRun(scip, var) - ccall((:SCIPgetVarConflictScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarConflictScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarConflictlengthScore(scip, var) - ccall((:SCIPgetVarConflictlengthScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarConflictlengthScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarConflictlengthScoreCurrentRun(scip, var) - ccall((:SCIPgetVarConflictlengthScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarConflictlengthScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarAvgConflictlength(scip, var, dir) - ccall((:SCIPgetVarAvgConflictlength, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarAvgConflictlength, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarAvgConflictlengthCurrentRun(scip, var, dir) - ccall((:SCIPgetVarAvgConflictlengthCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarAvgConflictlengthCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarAvgInferences(scip, var, dir) - ccall((:SCIPgetVarAvgInferences, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarAvgInferences, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarAvgInferencesCurrentRun(scip, var, dir) - ccall((:SCIPgetVarAvgInferencesCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarAvgInferencesCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarAvgInferenceScore(scip, var) - ccall((:SCIPgetVarAvgInferenceScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarAvgInferenceScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarAvgInferenceScoreCurrentRun(scip, var) - ccall((:SCIPgetVarAvgInferenceScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) -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) + 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) + ccall( + (:SCIPgetVarAvgCutoffs, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarAvgCutoffsCurrentRun(scip, var, dir) - ccall((:SCIPgetVarAvgCutoffsCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), scip, var, dir) + ccall( + (:SCIPgetVarAvgCutoffsCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + scip, + var, + dir, + ) end function SCIPgetVarAvgCutoffScore(scip, var) - ccall((:SCIPgetVarAvgCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarAvgCutoffScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarAvgCutoffScoreCurrentRun(scip, var) - ccall((:SCIPgetVarAvgCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarAvgCutoffScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPgetVarAvgInferenceCutoffScore(scip, var, cutoffweight) - ccall((:SCIPgetVarAvgInferenceCutoffScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) + ccall( + (:SCIPgetVarAvgInferenceCutoffScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + cutoffweight, + ) end function SCIPgetVarAvgInferenceCutoffScoreCurrentRun(scip, var, cutoffweight) - ccall((:SCIPgetVarAvgInferenceCutoffScoreCurrentRun, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, cutoffweight) + ccall( + (:SCIPgetVarAvgInferenceCutoffScoreCurrentRun, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + cutoffweight, + ) end function SCIPgetVarAvgGMIScore(scip, var) - ccall((:SCIPgetVarAvgGMIScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarAvgGMIScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPincVarGMISumScore(scip, var, gmieff) - ccall((:SCIPincVarGMISumScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, gmieff) + ccall( + (:SCIPincVarGMISumScore, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + gmieff, + ) end function SCIPgetVarLastGMIScore(scip, var) - ccall((:SCIPgetVarLastGMIScore, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, var) + ccall( + (:SCIPgetVarLastGMIScore, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + var, + ) end function SCIPsetVarLastGMIScore(scip, var, gmieff) - ccall((:SCIPsetVarLastGMIScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), scip, var, gmieff) + ccall( + (:SCIPsetVarLastGMIScore, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble), + scip, + var, + gmieff, + ) end function SCIPprintVar(scip, var, file) - ccall((:SCIPprintVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Libc.FILE}), scip, var, file) + ccall( + (:SCIPprintVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{Libc.FILE}), + scip, + var, + file, + ) end function SCIPchgVarObjExact(scip, var, newobj) - ccall((:SCIPchgVarObjExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newobj) + ccall( + (:SCIPchgVarObjExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + newobj, + ) end function SCIPchgVarUbGlobalExact(scip, var, newbound) - ccall((:SCIPchgVarUbGlobalExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) + ccall( + (:SCIPchgVarUbGlobalExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + newbound, + ) end function SCIPchgVarLbGlobalExact(scip, var, newbound) - ccall((:SCIPchgVarLbGlobalExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) + ccall( + (:SCIPchgVarLbGlobalExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + newbound, + ) end function SCIPwriteVarsLinearsumExact(scip, file, vars, vals, nvars, type) - ccall((:SCIPwriteVarsLinearsumExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint, Cuint), scip, file, vars, vals, nvars, type) -end - -function SCIPgetProbvarLinearSumExact(scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) - ccall((:SCIPgetProbvarLinearSumExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Cint}, Cint, Ptr{SCIP_RATIONAL}, Ptr{Cint}, Cuint), scip, vars, scalars, nvars, varssize, constant, requiredsize, mergemultiples) -end - -function SCIPselectVarPseudoStrongBranching(scip, pseudocands, skipdown, skipup, npseudocands, npriopseudocands, bestpseudocand, bestdown, bestup, bestscore, bestdownvalid, bestupvalid, provedbound, result) - ccall((:SCIPselectVarPseudoStrongBranching, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}, Ptr{Cuint}, Cint, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Ptr{SCIP_RESULT}), scip, pseudocands, skipdown, skipup, npseudocands, npriopseudocands, bestpseudocand, bestdown, bestup, bestscore, bestdownvalid, bestupvalid, provedbound, result) + ccall( + (:SCIPwriteVarsLinearsumExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Cint, + Cuint, + ), + scip, + file, + vars, + vals, + nvars, + type, + ) +end + +function SCIPgetProbvarLinearSumExact( + scip, + vars, + scalars, + nvars, + varssize, + constant, + requiredsize, + mergemultiples, +) + ccall( + (:SCIPgetProbvarLinearSumExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{Cint}, + Cint, + Ptr{SCIP_RATIONAL}, + Ptr{Cint}, + Cuint, + ), + scip, + vars, + scalars, + nvars, + varssize, + constant, + requiredsize, + mergemultiples, + ) +end + +function SCIPselectVarPseudoStrongBranching( + scip, + pseudocands, + skipdown, + skipup, + npseudocands, + npriopseudocands, + bestpseudocand, + bestdown, + bestup, + bestscore, + bestdownvalid, + bestupvalid, + provedbound, + result, +) + ccall( + (:SCIPselectVarPseudoStrongBranching, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cuint}, + Ptr{Cuint}, + Cint, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cdouble}, + Ptr{SCIP_RESULT}, + ), + scip, + pseudocands, + skipdown, + skipup, + npseudocands, + npriopseudocands, + bestpseudocand, + bestdown, + bestup, + bestscore, + bestdownvalid, + bestupvalid, + provedbound, + result, + ) end function SCIPincludeBranchruleAllfullstrong(scip) - ccall((:SCIPincludeBranchruleAllfullstrong, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleAllfullstrong, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleCloud(scip) - ccall((:SCIPincludeBranchruleCloud, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleCloud, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleDistribution(scip) - ccall((:SCIPincludeBranchruleDistribution, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPvarCalcDistributionParameters(scip, varlb, varub, vartype, impltype, mean, variance) - ccall((:SCIPvarCalcDistributionParameters, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, SCIP_VARTYPE, SCIP_IMPLINTTYPE, Ptr{Cdouble}, Ptr{Cdouble}), scip, varlb, varub, vartype, impltype, mean, variance) + ccall( + (:SCIPincludeBranchruleDistribution, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPvarCalcDistributionParameters( + scip, + varlb, + varub, + vartype, + impltype, + mean, + variance, +) + ccall( + (:SCIPvarCalcDistributionParameters, libscip), + Cvoid, + ( + Ptr{SCIP}, + Cdouble, + Cdouble, + SCIP_VARTYPE, + SCIP_IMPLINTTYPE, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + scip, + varlb, + varub, + vartype, + impltype, + mean, + variance, + ) end function SCIPcalcCumulativeDistribution(scip, mean, variance, value) - ccall((:SCIPcalcCumulativeDistribution, libscip), Cdouble, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), scip, mean, variance, value) -end - -function SCIProwCalcProbability(scip, row, mu, sigma2, rowinfinitiesdown, rowinfinitiesup) - ccall((:SCIProwCalcProbability, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Cint, Cint), scip, row, mu, sigma2, rowinfinitiesdown, rowinfinitiesup) -end - -function SCIPupdateDistributionScore(scip, currentprob, newprobup, newprobdown, upscore, downscore, scoreparam) - ccall((:SCIPupdateDistributionScore, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Cchar), scip, currentprob, newprobup, newprobdown, upscore, downscore, scoreparam) + ccall( + (:SCIPcalcCumulativeDistribution, libscip), + Cdouble, + (Ptr{SCIP}, Cdouble, Cdouble, Cdouble), + scip, + mean, + variance, + value, + ) +end + +function SCIProwCalcProbability( + scip, + row, + mu, + sigma2, + rowinfinitiesdown, + rowinfinitiesup, +) + ccall( + (:SCIProwCalcProbability, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROW}, Cdouble, Cdouble, Cint, Cint), + scip, + row, + mu, + sigma2, + rowinfinitiesdown, + rowinfinitiesup, + ) +end + +function SCIPupdateDistributionScore( + scip, + currentprob, + newprobup, + newprobdown, + upscore, + downscore, + scoreparam, +) + ccall( + (:SCIPupdateDistributionScore, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cdouble, + Cdouble, + Cdouble, + Ptr{Cdouble}, + Ptr{Cdouble}, + Cchar, + ), + scip, + currentprob, + newprobup, + newprobdown, + upscore, + downscore, + scoreparam, + ) end function SCIPincludeBranchruleFullstrong(scip) - ccall((:SCIPincludeBranchruleFullstrong, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPselectVarStrongBranching(scip, lpcands, lpcandssol, lpcandsfrac, skipdown, skipup, nlpcands, npriolpcands, ncomplete, start, maxproprounds, probingbounds, forcestrongbranch, bestcand, bestdown, bestup, bestscore, bestdownvalid, bestupvalid, provedbound, result) - ccall((:SCIPselectVarStrongBranching, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Cint, Cint, Cint, Ptr{Cint}, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Ptr{SCIP_RESULT}), scip, lpcands, lpcandssol, lpcandsfrac, skipdown, skipup, nlpcands, npriolpcands, ncomplete, start, maxproprounds, probingbounds, forcestrongbranch, bestcand, bestdown, bestup, bestscore, bestdownvalid, bestupvalid, provedbound, result) + ccall( + (:SCIPincludeBranchruleFullstrong, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPselectVarStrongBranching( + scip, + lpcands, + lpcandssol, + lpcandsfrac, + skipdown, + skipup, + nlpcands, + npriolpcands, + ncomplete, + start, + maxproprounds, + probingbounds, + forcestrongbranch, + bestcand, + bestdown, + bestup, + bestscore, + bestdownvalid, + bestupvalid, + provedbound, + result, +) + ccall( + (:SCIPselectVarStrongBranching, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Cint, + Cint, + Cint, + Ptr{Cint}, + Cint, + Cuint, + Cuint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cdouble}, + Ptr{SCIP_RESULT}, + ), + scip, + lpcands, + lpcandssol, + lpcandsfrac, + skipdown, + skipup, + nlpcands, + npriolpcands, + ncomplete, + start, + maxproprounds, + probingbounds, + forcestrongbranch, + bestcand, + bestdown, + bestup, + bestscore, + bestdownvalid, + bestupvalid, + provedbound, + result, + ) end function SCIPincludeBranchruleGomory(scip) - ccall((:SCIPincludeBranchruleGomory, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleGomory, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleInference(scip) - ccall((:SCIPincludeBranchruleInference, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleInference, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleLeastinf(scip) - ccall((:SCIPincludeBranchruleLeastinf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleLeastinf, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleLookahead(scip) - ccall((:SCIPincludeBranchruleLookahead, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleLookahead, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleMostinf(scip) - ccall((:SCIPincludeBranchruleMostinf, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleMostinf, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleMultAggr(scip) - ccall((:SCIPincludeBranchruleMultAggr, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleMultAggr, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleNodereopt(scip) - ccall((:SCIPincludeBranchruleNodereopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleNodereopt, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchrulePscost(scip) - ccall((:SCIPincludeBranchrulePscost, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPselectBranchVarPscost(scip, branchcands, branchcandssol, branchcandsscore, nbranchcands, var, brpoint) - ccall((:SCIPselectBranchVarPscost, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, branchcands, branchcandssol, branchcandsscore, nbranchcands, var, brpoint) + ccall( + (:SCIPincludeBranchrulePscost, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPselectBranchVarPscost( + scip, + branchcands, + branchcandssol, + branchcandsscore, + nbranchcands, + var, + brpoint, +) + ccall( + (:SCIPselectBranchVarPscost, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + ), + scip, + branchcands, + branchcandssol, + branchcandsscore, + nbranchcands, + var, + brpoint, + ) end function SCIPincludeBranchruleRandom(scip) - ccall((:SCIPincludeBranchruleRandom, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBranchruleRandom, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBranchruleRelpscost(scip) - ccall((:SCIPincludeBranchruleRelpscost, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPexecRelpscostBranching(scip, branchcands, branchcandssol, branchcandsfrac, nbranchcands, executebranching, result) - ccall((:SCIPexecRelpscostBranching, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Cint, Cuint, Ptr{SCIP_RESULT}), scip, branchcands, branchcandssol, branchcandsfrac, nbranchcands, executebranching, result) + ccall( + (:SCIPincludeBranchruleRelpscost, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPexecRelpscostBranching( + scip, + branchcands, + branchcandssol, + branchcandsfrac, + nbranchcands, + executebranching, + result, +) + ccall( + (:SCIPexecRelpscostBranching, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Cint, + Cuint, + Ptr{SCIP_RESULT}, + ), + scip, + branchcands, + branchcandssol, + branchcandsfrac, + nbranchcands, + executebranching, + result, + ) end function SCIPincludeBranchruleVanillafullstrong(scip) - ccall((:SCIPincludeBranchruleVanillafullstrong, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPgetVanillafullstrongData(scip, cands, candscores, ncands, npriocands, bestcand) - ccall((:SCIPgetVanillafullstrongData, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, cands, candscores, ncands, npriocands, bestcand) + ccall( + (:SCIPincludeBranchruleVanillafullstrong, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPgetVanillafullstrongData( + scip, + cands, + candscores, + ncands, + npriocands, + bestcand, +) + ccall( + (:SCIPgetVanillafullstrongData, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Ptr{Cdouble}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + cands, + candscores, + ncands, + npriocands, + bestcand, + ) end function SCIPincludeComprLargestrepr(scip) - ccall((:SCIPincludeComprLargestrepr, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeComprLargestrepr, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeComprWeakcompr(scip) - ccall((:SCIPincludeComprWeakcompr, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeComprWeakcompr, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, resvar, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, resvar, nvars, vars) + ccall( + (:SCIPcreateConsBasicAnd, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + 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) + 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) + 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) + ccall( + (:SCIPgetResultantAnd, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPisAndConsSorted(scip, cons) - ccall((:SCIPisAndConsSorted, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPisAndConsSorted, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPsortAndCons(scip, cons) - ccall((:SCIPsortAndCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPsortAndCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end 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, Cuint), scip, sol, conshdlr, result, type, checkint) + 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, + Cuint, + ), + scip, + sol, + conshdlr, + result, + type, + checkint, + ) end function SCIPincludeConshdlrBenderslp(scip) - ccall((:SCIPincludeConshdlrBenderslp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrBenderslp, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}), scip, cons, name, nvars, vars, boundtypes, bounds) -end - -function SCIPcreateConsBounddisjunctionRedundant(scip, cons, name, nvars, vars, boundtypes, bounds, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsBounddisjunctionRedundant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, boundtypes, bounds, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) -end - -function SCIPcreateConsBasicBounddisjunctionRedundant(scip, cons, name, nvars, vars, boundtypes, bounds) - ccall((:SCIPcreateConsBasicBounddisjunctionRedundant, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cdouble}), scip, cons, name, nvars, vars, boundtypes, bounds) + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{SCIP_BOUNDTYPE}, + Ptr{Cdouble}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{SCIP_BOUNDTYPE}, + Ptr{Cdouble}, + ), + scip, + cons, + name, + nvars, + vars, + boundtypes, + bounds, + ) +end + +function SCIPcreateConsBounddisjunctionRedundant( + scip, + cons, + name, + nvars, + vars, + boundtypes, + bounds, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsBounddisjunctionRedundant, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{SCIP_BOUNDTYPE}, + Ptr{Cdouble}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + nvars, + vars, + boundtypes, + bounds, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsBasicBounddisjunctionRedundant( + scip, + cons, + name, + nvars, + vars, + boundtypes, + bounds, +) + ccall( + (:SCIPcreateConsBasicBounddisjunctionRedundant, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetBoundsBounddisjunction, libscip), + Ptr{Cdouble}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, name, nvars, vars, cardval, indvars, weights) + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + 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) + 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetWeightsCardinality, libscip), + Ptr{Cdouble}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_CONS}}, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nconss, conss, enforce, check, _local, modifiable, dynamic) + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_CONS}}), scip, cons, name, nconss, conss) + ccall( + (:SCIPcreateConsBasicConjunction, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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) + ccall( + (:SCIPaddConsElemConjunction, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), + scip, + cons, + addcons, + ) end function SCIPincludeConshdlrCountsols(scip) - ccall((:SCIPincludeConshdlrCountsols, libscip), SCIP_RETCODE, (Ptr{SCIP},), 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) + 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) + 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) + 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) @@ -10466,19 +27823,53 @@ function SCIPcount(scip) end function SCIPgetNCountedSols(scip, valid) - ccall((:SCIPgetNCountedSols, libscip), Clonglong, (Ptr{SCIP}, Ptr{Cuint}), scip, valid) + ccall( + (:SCIPgetNCountedSols, libscip), + Clonglong, + (Ptr{SCIP}, Ptr{Cuint}), + scip, + valid, + ) end function SCIPgetNCountedSolsstr(scip, buffer, buffersize, requiredsize) - ccall((:SCIPgetNCountedSolsstr, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}), scip, buffer, buffersize, requiredsize) + ccall( + (:SCIPgetNCountedSolsstr, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}), + scip, + buffer, + buffersize, + requiredsize, + ) end function SCIPgetNCountedFeasSubtrees(scip) - ccall((:SCIPgetNCountedFeasSubtrees, libscip), Clonglong, (Ptr{SCIP},), 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) + 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) @@ -10486,171 +27877,1171 @@ function SCIPsetParamsCountsols(scip) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Ptr{Cint}, Cint), scip, cons, name, nvars, vars, durations, demands, capacity) + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cint}, + Ptr{Cint}, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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{Cuint}, Ptr{SCIP_CONS}, Cuint), 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, irrelevants, nfixedvars, nchgsides, cutoff) - ccall((:SCIPpresolveCumulativeCondition, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint, Cint, Ptr{Cuint}, Ptr{Cuint}, Ptr{SCIP_CONS}, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}), scip, nvars, vars, durations, hmin, hmax, downlocks, uplocks, cons, irrelevants, 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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{Cuint}, Ptr{SCIP_RESULT}), scip, nvars, vars, durations, demands, capacity, hmin, hmax, infervar, inferinfo, boundtype, bdchgidx, relaxedbd, explanation, result) + 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{Cuint}, + Ptr{SCIP_CONS}, + Cuint, + ), + 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, + irrelevants, + nfixedvars, + nchgsides, + cutoff, +) + ccall( + (:SCIPpresolveCumulativeCondition, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cint}, + Cint, + Cint, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{SCIP_CONS}, + Ptr{Cuint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cuint}, + ), + scip, + nvars, + vars, + durations, + hmin, + hmax, + downlocks, + uplocks, + cons, + irrelevants, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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{Cuint}, + 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) + 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{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), 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) + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + 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) + 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) + ccall( + (:SCIPcomputeHmax, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_PROFILE}, Cint), + scip, + profile, + capacity, + ) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONS}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP_CONS}), scip, cons, name, nconss, conss, relaxcons) + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Ptr{SCIP_CONS}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + 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) + ccall( + (:SCIPaddConsElemDisjunction, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_CONS}), + scip, + cons, + addcons, + ) end function SCIPincludeConshdlrFixedvar(scip) - ccall((:SCIPincludeConshdlrFixedvar, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrFixedvar, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble), scip, cons, name, binvar, nvars, vars, vals, rhs) -end - -function SCIPcreateConsIndicatorGeneric(scip, cons, name, binvar, nvars, vars, vals, rhs, activeone, lessthanineq, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsIndicatorGeneric, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, nvars, vars, vals, rhs, activeone, lessthanineq, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) -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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, lincons, slackvar, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) -end - -function SCIPcreateConsIndicatorGenericLinCons(scip, cons, name, binvar, lincons, slackvar, activeone, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsIndicatorGenericLinCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, lincons, slackvar, activeone, 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, name, binvar, lincons, slackvar) -end - -function SCIPcreateConsIndicatorGenericLinConsPure(scip, cons, name, binvar, lincons, activeone, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsIndicatorGenericLinConsPure, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, lincons, activeone, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) -end - -function SCIPcreateConsIndicatorLinConsPure(scip, cons, name, binvar, lincons, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsIndicatorLinConsPure, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, lincons, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + 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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cdouble, + ), + scip, + cons, + name, + binvar, + nvars, + vars, + vals, + rhs, + ) +end + +function SCIPcreateConsIndicatorGeneric( + scip, + cons, + name, + binvar, + nvars, + vars, + vals, + rhs, + activeone, + lessthanineq, + initial, + separate, + enforce, + check, + propagate, + _local, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsIndicatorGeneric, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + binvar, + nvars, + vars, + vals, + rhs, + activeone, + lessthanineq, + initial, + separate, + enforce, + check, + propagate, + _local, + dynamic, + removable, + stickingatnode, + ) +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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_CONS}, + Ptr{SCIP_VAR}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + binvar, + lincons, + slackvar, + initial, + separate, + enforce, + check, + propagate, + _local, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsIndicatorGenericLinCons( + scip, + cons, + name, + binvar, + lincons, + slackvar, + activeone, + initial, + separate, + enforce, + check, + propagate, + _local, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsIndicatorGenericLinCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_CONS}, + Ptr{SCIP_VAR}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + binvar, + lincons, + slackvar, + activeone, + 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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_CONS}, + Ptr{SCIP_VAR}, + ), + scip, + cons, + name, + binvar, + lincons, + slackvar, + ) +end + +function SCIPcreateConsIndicatorGenericLinConsPure( + scip, + cons, + name, + binvar, + lincons, + activeone, + initial, + separate, + enforce, + check, + propagate, + _local, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsIndicatorGenericLinConsPure, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_CONS}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + binvar, + lincons, + activeone, + initial, + separate, + enforce, + check, + propagate, + _local, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsIndicatorLinConsPure( + scip, + cons, + name, + binvar, + lincons, + initial, + separate, + enforce, + check, + propagate, + _local, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsIndicatorLinConsPure, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_CONS}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + binvar, + lincons, + initial, + separate, + enforce, + check, + propagate, + _local, + dynamic, + removable, + stickingatnode, + ) 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) + 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) + 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) + 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) + ccall( + (:SCIPsetBinaryVarIndicator, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), + scip, + cons, + binvar, + ) end function SCIPgetActiveOnIndicator(cons) @@ -10658,119 +29049,507 @@ function SCIPgetActiveOnIndicator(cons) end function SCIPgetBinaryVarIndicator(cons) - ccall((:SCIPgetBinaryVarIndicator, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_CONS},), cons) + ccall( + (:SCIPgetBinaryVarIndicator, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPgetBinaryVarIndicatorGeneric(cons) - ccall((:SCIPgetBinaryVarIndicatorGeneric, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_CONS},), cons) + ccall( + (:SCIPgetBinaryVarIndicatorGeneric, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPgetSlackVarIndicator(cons) - ccall((:SCIPgetSlackVarIndicator, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_CONS},), 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) + ccall( + (:SCIPsetSlackVarUb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), + scip, + cons, + ub, + ) end function SCIPisViolatedIndicator(scip, cons, sol) - ccall((:SCIPisViolatedIndicator, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}), scip, cons, sol) + ccall( + (:SCIPisViolatedIndicator, libscip), + Cuint, + (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{Cuint}), scip, cons, sol, changed) + ccall( + (:SCIPmakeIndicatorFeasible, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cuint}), + 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{Cuint}), scip, conshdlr, sol, changed) + ccall( + (:SCIPmakeIndicatorsFeasible, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_SOL}, Ptr{Cuint}), + 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) + 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) + ccall( + (:SCIPaddRowIndicator, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_ROW}), + scip, + conshdlr, + row, + ) end function SCIPincludeConshdlrIntegral(scip) - ccall((:SCIPincludeConshdlrIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrIntegral, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Clonglong}, Clonglong, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Clonglong}, Clonglong), scip, cons, name, nvars, vars, weights, capacity) + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Clonglong}, + Clonglong, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetRowKnapsack, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPcreateRowKnapsack(scip, cons) - ccall((:SCIPcreateRowKnapsack, libscip), SCIP_RETCODE, (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{Cuint}), 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}, Cuint, Ptr{Cuint}, 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{Cuint}, Ptr{Cint}), scip, cons, sepa, nknapvars, knapvars, knapvals, valscale, rhs, sol, cutoff, ncuts) + ccall( + (:SCIPcreateRowKnapsack, libscip), + SCIP_RETCODE, + (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{Cuint}, + ), + 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}, + Cuint, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cint}, + ), + scip, + cons, + sepa, + nknapvars, + knapvars, + knapvals, + valscale, + rhs, + sol, + cutoff, + ncuts, + ) end function SCIPcleanupConssKnapsack(scip, onlychecked, infeasible, ndelconss) - ccall((:SCIPcleanupConssKnapsack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}), scip, onlychecked, infeasible, ndelconss) + ccall( + (:SCIPcleanupConssKnapsack, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}), + scip, + onlychecked, + infeasible, + ndelconss, + ) end function SCIPincludeConshdlrLinear(scip) - ccall((:SCIPincludeConshdlrLinear, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end const SCIP_LinConsUpgrade = Cvoid @@ -10778,315 +29557,1403 @@ const SCIP_LinConsUpgrade = Cvoid const SCIP_LINCONSUPGRADE = SCIP_LinConsUpgrade function SCIPincludeLinconsUpgrade(scip, linconsupgd, priority, conshdlrname) - ccall((:SCIPincludeLinconsUpgrade, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}, Cint, Ptr{Cchar}), scip, linconsupgd, priority, conshdlrname) + ccall( + (:SCIPincludeLinconsUpgrade, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cvoid}, Cint, Ptr{Cchar}), + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + 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}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + 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 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), 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) +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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetRowLinear, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPcreateRowLinear(scip, cons) - ccall((:SCIPcreateRowLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPcreateRowLinear, libscip), + SCIP_RETCODE, + (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) + 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) + ccall( + (:SCIPclassifyConstraintTypesLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_LINCONSSTATS}), + scip, + linconsstats, + ) end function SCIPcleanupConssLinear(scip, onlychecked, infeasible, ndelconss) - ccall((:SCIPcleanupConssLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}), scip, onlychecked, infeasible, ndelconss) + ccall( + (:SCIPcleanupConssLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}), + scip, + onlychecked, + infeasible, + ndelconss, + ) end function SCIPincludeConshdlrExactLinear(scip) - ccall((:SCIPincludeConshdlrExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPcreateConsExactLinear(scip, cons, name, nvars, vars, vals, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, vals, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) -end - -function SCIPcreateConsBasicExactLinear(scip, cons, name, nvars, vars, vals, lhs, rhs) - ccall((:SCIPcreateConsBasicExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), scip, cons, name, nvars, vars, vals, lhs, rhs) -end - -function SCIPcopyConsExactLinear(scip, cons, sourcescip, name, nvars, sourcevars, sourcecoefs, lhs, rhs, varmap, consmap, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) - ccall((:SCIPcopyConsExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{SCIP}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_INTERVAL}, Cdouble, Cdouble, Ptr{SCIP_HASHMAP}, Ptr{SCIP_HASHMAP}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), scip, cons, sourcescip, name, nvars, sourcevars, sourcecoefs, lhs, rhs, varmap, consmap, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode, _global, valid) + ccall( + (:SCIPincludeConshdlrExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPcreateConsExactLinear( + scip, + cons, + name, + nvars, + vars, + vals, + lhs, + rhs, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsExactLinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + nvars, + vars, + vals, + lhs, + rhs, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsBasicExactLinear( + scip, + cons, + name, + nvars, + vars, + vals, + lhs, + rhs, +) + ccall( + (:SCIPcreateConsBasicExactLinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + ), + scip, + cons, + name, + nvars, + vars, + vals, + lhs, + rhs, + ) +end + +function SCIPcopyConsExactLinear( + scip, + cons, + sourcescip, + name, + nvars, + sourcevars, + sourcecoefs, + lhs, + rhs, + varmap, + consmap, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + _global, + valid, +) + ccall( + (:SCIPcopyConsExactLinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{SCIP}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{SCIP_INTERVAL}, + Cdouble, + Cdouble, + Ptr{SCIP_HASHMAP}, + Ptr{SCIP_HASHMAP}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + 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 SCIPaddCoefExactLinear(scip, cons, var, val) - ccall((:SCIPaddCoefExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, cons, var, val) + ccall( + (:SCIPaddCoefExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + cons, + var, + val, + ) end function SCIPchgCoefExactLinear(scip, cons, var, val) - ccall((:SCIPchgCoefExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, cons, var, val) + ccall( + (:SCIPchgCoefExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + cons, + var, + val, + ) end function SCIPdelCoefExactLinear(scip, cons, var) - ccall((:SCIPdelCoefExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), scip, cons, var) + ccall( + (:SCIPdelCoefExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}), + scip, + cons, + var, + ) end function SCIPgetLhsExactLinear(scip, cons) - ccall((:SCIPgetLhsExactLinear, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetLhsExactLinear, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetRhsExactLinear(scip, cons) - ccall((:SCIPgetRhsExactLinear, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetRhsExactLinear, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPchgLhsExactLinear(scip, cons, lhs) - ccall((:SCIPchgLhsExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), scip, cons, lhs) + ccall( + (:SCIPchgLhsExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), + scip, + cons, + lhs, + ) end function SCIPchgRhsExactLinear(scip, cons, rhs) - ccall((:SCIPchgRhsExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), scip, cons, rhs) + ccall( + (:SCIPchgRhsExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), + scip, + cons, + rhs, + ) end function SCIPgetNVarsExactLinear(scip, cons) - ccall((:SCIPgetNVarsExactLinear, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetNVarsExactLinear, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetVarsExactLinear(scip, cons) - ccall((:SCIPgetVarsExactLinear, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetVarsExactLinear, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetValsRealExactLinear(scip, cons) - ccall((:SCIPgetValsRealExactLinear, libscip), Ptr{SCIP_INTERVAL}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetValsRealExactLinear, libscip), + Ptr{SCIP_INTERVAL}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetValsExactLinear(scip, cons) - ccall((:SCIPgetValsExactLinear, libscip), Ptr{Ptr{SCIP_RATIONAL}}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetValsExactLinear, libscip), + Ptr{Ptr{SCIP_RATIONAL}}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetActivityExactLinear(scip, cons, sol, ret) - ccall((:SCIPgetActivityExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, cons, sol, ret) + ccall( + (:SCIPgetActivityExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), + scip, + cons, + sol, + ret, + ) end function SCIPgetFeasibilityExactLinear(scip, cons, sol, ret) - ccall((:SCIPgetFeasibilityExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, cons, sol, ret) + ccall( + (:SCIPgetFeasibilityExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), + scip, + cons, + sol, + ret, + ) end function SCIPgetFpDualsolExactLinear(scip, cons, ret) - ccall((:SCIPgetFpDualsolExactLinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), scip, cons, ret) + ccall( + (:SCIPgetFpDualsolExactLinear, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), + scip, + cons, + ret, + ) end function SCIPgetFpDualfarkasExactLinear(scip, cons, ret) - ccall((:SCIPgetFpDualfarkasExactLinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), scip, cons, ret) + ccall( + (:SCIPgetFpDualfarkasExactLinear, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_RATIONAL}), + scip, + cons, + ret, + ) end function SCIPgetRowExactLinear(scip, cons) - ccall((:SCIPgetRowExactLinear, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetRowExactLinear, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetRowExactExactLinear(scip, cons) - ccall((:SCIPgetRowExactExactLinear, libscip), Ptr{SCIP_ROWEXACT}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetRowExactExactLinear, libscip), + Ptr{SCIP_ROWEXACT}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPcertifyConsOrigExactLinear(scip, conshdlr, cons) - ccall((:SCIPcertifyConsOrigExactLinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONS}), scip, conshdlr, cons) + ccall( + (:SCIPcertifyConsOrigExactLinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONS}), + scip, + conshdlr, + cons, + ) end function colLink(col, blkmem, set, eventqueue, lp) - ccall((:colLink, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), col, blkmem, set, eventqueue, lp) + ccall( + (:colLink, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + ), + col, + blkmem, + set, + eventqueue, + lp, + ) end function colUnlink(col, blkmem, set, eventqueue, lp) - ccall((:colUnlink, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), col, blkmem, set, eventqueue, lp) + ccall( + (:colUnlink, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + ), + col, + blkmem, + set, + eventqueue, + lp, + ) end function rowLink(row, blkmem, set, eventqueue, lp) - ccall((:rowLink, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), row, blkmem, set, eventqueue, lp) + ccall( + (:rowLink, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + ), + row, + blkmem, + set, + eventqueue, + lp, + ) end function rowUnlink(row, set, lp) - ccall((:rowUnlink, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), row, set, lp) + ccall( + (:rowUnlink, libscip), + SCIP_RETCODE, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), + row, + set, + lp, + ) end function SCIPcolCreate(col, blkmem, set, stat, var, len, rows, vals, removable) - ccall((:SCIPcolCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_ROW}}, Ptr{Cdouble}, Cuint), col, blkmem, set, stat, var, len, rows, vals, removable) + ccall( + (:SCIPcolCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_COL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_VAR}, + Cint, + Ptr{Ptr{SCIP_ROW}}, + Ptr{Cdouble}, + Cuint, + ), + col, + blkmem, + set, + stat, + var, + len, + rows, + vals, + removable, + ) end function SCIPcolFree(col, blkmem, set, eventqueue, lp) - ccall((:SCIPcolFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), col, blkmem, set, eventqueue, lp) + ccall( + (:SCIPcolFree, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_COL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + ), + col, + blkmem, + set, + eventqueue, + lp, + ) end function SCIPcolPrint(col, messagehdlr, file) - ccall((:SCIPcolPrint, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), col, messagehdlr, file) + ccall( + (:SCIPcolPrint, libscip), + Cvoid, + (Ptr{SCIP_COL}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), + col, + messagehdlr, + file, + ) end function SCIPcolAddCoef(col, blkmem, set, eventqueue, lp, row, val) - ccall((:SCIPcolAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_ROW}, Cdouble), col, blkmem, set, eventqueue, lp, row, val) + ccall( + (:SCIPcolAddCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Ptr{SCIP_ROW}, + Cdouble, + ), + col, + blkmem, + set, + eventqueue, + lp, + row, + val, + ) end function SCIPcolDelCoef(col, blkmem, set, eventqueue, lp, row) - ccall((:SCIPcolDelCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_ROW}), col, blkmem, set, eventqueue, lp, row) + ccall( + (:SCIPcolDelCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Ptr{SCIP_ROW}, + ), + col, + blkmem, + set, + eventqueue, + lp, + row, + ) end function SCIPcolChgCoef(col, blkmem, set, eventqueue, lp, row, val) - ccall((:SCIPcolChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_ROW}, Cdouble), col, blkmem, set, eventqueue, lp, row, val) + ccall( + (:SCIPcolChgCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Ptr{SCIP_ROW}, + Cdouble, + ), + col, + blkmem, + set, + eventqueue, + lp, + row, + val, + ) end function SCIPcolIncCoef(col, blkmem, set, eventqueue, lp, row, incval) - ccall((:SCIPcolIncCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_ROW}, Cdouble), col, blkmem, set, eventqueue, lp, row, incval) + ccall( + (:SCIPcolIncCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Ptr{SCIP_ROW}, + Cdouble, + ), + col, + blkmem, + set, + eventqueue, + lp, + row, + incval, + ) end function SCIPcolChgObj(col, set, lp, newobj) - ccall((:SCIPcolChgObj, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), col, set, lp, newobj) + ccall( + (:SCIPcolChgObj, libscip), + SCIP_RETCODE, + (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), + col, + set, + lp, + newobj, + ) end function SCIPcolChgLb(col, set, lp, newlb) - ccall((:SCIPcolChgLb, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), col, set, lp, newlb) + ccall( + (:SCIPcolChgLb, libscip), + SCIP_RETCODE, + (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), + col, + set, + lp, + newlb, + ) end function SCIPcolChgUb(col, set, lp, newub) - ccall((:SCIPcolChgUb, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), col, set, lp, newub) + ccall( + (:SCIPcolChgUb, libscip), + SCIP_RETCODE, + (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), + col, + set, + lp, + newub, + ) end function SCIPcolCalcRedcost(col, dualsol) - ccall((:SCIPcolCalcRedcost, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{Cdouble}), col, dualsol) + ccall( + (:SCIPcolCalcRedcost, libscip), + Cdouble, + (Ptr{SCIP_COL}, Ptr{Cdouble}), + col, + dualsol, + ) end function SCIPcolGetRedcost(col, stat, lp) - ccall((:SCIPcolGetRedcost, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, stat, lp) + ccall( + (:SCIPcolGetRedcost, libscip), + Cdouble, + (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), + col, + stat, + lp, + ) end function SCIPcolGetFeasibility(col, set, stat, lp) - ccall((:SCIPcolGetFeasibility, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, set, stat, lp) + ccall( + (:SCIPcolGetFeasibility, libscip), + Cdouble, + (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), + col, + set, + stat, + lp, + ) end function SCIPcolCalcFarkasCoef(col, dualfarkas) - ccall((:SCIPcolCalcFarkasCoef, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{Cdouble}), col, dualfarkas) + ccall( + (:SCIPcolCalcFarkasCoef, libscip), + Cdouble, + (Ptr{SCIP_COL}, Ptr{Cdouble}), + col, + dualfarkas, + ) end function SCIPcolGetFarkasCoef(col, stat, lp) - ccall((:SCIPcolGetFarkasCoef, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, stat, lp) + ccall( + (:SCIPcolGetFarkasCoef, libscip), + Cdouble, + (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), + col, + stat, + lp, + ) end function SCIPcolGetFarkasValue(col, stat, lp) - ccall((:SCIPcolGetFarkasValue, libscip), Cdouble, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, stat, lp) + ccall( + (:SCIPcolGetFarkasValue, libscip), + Cdouble, + (Ptr{SCIP_COL}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), + col, + stat, + lp, + ) end function SCIPlpStartStrongbranch(lp) - ccall((:SCIPlpStartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_LP},), lp) + ccall( + (:SCIPlpStartStrongbranch, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP},), + lp, + ) end function SCIPlpEndStrongbranch(lp) ccall((:SCIPlpEndStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_LP},), lp) end -function SCIPcolSetStrongbranchData(col, set, stat, lp, lpobjval, primsol, sbdown, sbup, sbdownvalid, sbupvalid, iter, itlim) - ccall((:SCIPcolSetStrongbranchData, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}, Cdouble, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Clonglong, Cint), col, set, stat, lp, lpobjval, primsol, sbdown, sbup, sbdownvalid, sbupvalid, iter, itlim) +function SCIPcolSetStrongbranchData( + col, + set, + stat, + lp, + lpobjval, + primsol, + sbdown, + sbup, + sbdownvalid, + sbupvalid, + iter, + itlim, +) + ccall( + (:SCIPcolSetStrongbranchData, libscip), + Cvoid, + ( + Ptr{SCIP_COL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_LP}, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cuint, + Cuint, + Clonglong, + Cint, + ), + col, + set, + stat, + lp, + lpobjval, + primsol, + sbdown, + sbup, + sbdownvalid, + sbupvalid, + iter, + itlim, + ) end function SCIPcolInvalidateStrongbranchData(col, set, stat, lp) - ccall((:SCIPcolInvalidateStrongbranchData, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), col, set, stat, lp) -end - -function SCIPcolGetStrongbranch(col, integral, set, stat, prob, lp, itlim, updatecol, updatestat, down, up, downvalid, upvalid, lperror) - ccall((:SCIPcolGetStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_COL}, Cuint, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Cint, Cuint, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), col, integral, set, stat, prob, lp, itlim, updatecol, updatestat, down, up, downvalid, upvalid, lperror) -end - -function SCIPcolGetStrongbranches(cols, ncols, integral, set, stat, prob, lp, itlim, down, up, downvalid, upvalid, lperror) - ccall((:SCIPcolGetStrongbranches, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COL}}, Cint, Cuint, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}), cols, ncols, integral, set, stat, prob, lp, itlim, down, up, downvalid, upvalid, lperror) -end - -function SCIPcolGetStrongbranchLast(col, down, up, downvalid, upvalid, solval, lpobjval) - ccall((:SCIPcolGetStrongbranchLast, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Ptr{Cdouble}), col, down, up, downvalid, upvalid, solval, lpobjval) + ccall( + (:SCIPcolInvalidateStrongbranchData, libscip), + Cvoid, + (Ptr{SCIP_COL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), + col, + set, + stat, + lp, + ) +end + +function SCIPcolGetStrongbranch( + col, + integral, + set, + stat, + prob, + lp, + itlim, + updatecol, + updatestat, + down, + up, + downvalid, + upvalid, + lperror, +) + ccall( + (:SCIPcolGetStrongbranch, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COL}, + Cuint, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + Cint, + Cuint, + Cuint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + col, + integral, + set, + stat, + prob, + lp, + itlim, + updatecol, + updatestat, + down, + up, + downvalid, + upvalid, + lperror, + ) +end + +function SCIPcolGetStrongbranches( + cols, + ncols, + integral, + set, + stat, + prob, + lp, + itlim, + down, + up, + downvalid, + upvalid, + lperror, +) + ccall( + (:SCIPcolGetStrongbranches, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_COL}}, + Cint, + Cuint, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + cols, + ncols, + integral, + set, + stat, + prob, + lp, + itlim, + down, + up, + downvalid, + upvalid, + lperror, + ) +end + +function SCIPcolGetStrongbranchLast( + col, + down, + up, + downvalid, + upvalid, + solval, + lpobjval, +) + ccall( + (:SCIPcolGetStrongbranchLast, libscip), + Cvoid, + ( + Ptr{SCIP_COL}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + col, + down, + up, + downvalid, + upvalid, + solval, + lpobjval, + ) end function SCIPcolGetStrongbranchLPAge(col, stat) - ccall((:SCIPcolGetStrongbranchLPAge, libscip), Clonglong, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}), col, stat) + ccall( + (:SCIPcolGetStrongbranchLPAge, libscip), + Clonglong, + (Ptr{SCIP_COL}, Ptr{SCIP_STAT}), + col, + stat, + ) end function SCIPcolMarkNotRemovableLocal(col, stat) - ccall((:SCIPcolMarkNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP_COL}, Ptr{SCIP_STAT}), col, stat) -end - -function SCIProwCreate(row, blkmem, set, stat, name, len, cols, vals, lhs, rhs, origintype, origin, _local, modifiable, removable) - ccall((:SCIProwCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROW}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_COL}}, Ptr{Cdouble}, Cdouble, Cdouble, SCIP_ROWORIGINTYPE, Ptr{Cvoid}, Cuint, Cuint, Cuint), row, blkmem, set, stat, name, len, cols, vals, lhs, rhs, origintype, origin, _local, modifiable, removable) + ccall( + (:SCIPcolMarkNotRemovableLocal, libscip), + Cvoid, + (Ptr{SCIP_COL}, Ptr{SCIP_STAT}), + col, + stat, + ) +end + +function SCIProwCreate( + row, + blkmem, + set, + stat, + name, + len, + cols, + vals, + lhs, + rhs, + origintype, + origin, + _local, + modifiable, + removable, +) + ccall( + (:SCIProwCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_ROW}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_COL}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + SCIP_ROWORIGINTYPE, + Ptr{Cvoid}, + Cuint, + Cuint, + Cuint, + ), + row, + blkmem, + set, + stat, + name, + len, + cols, + vals, + lhs, + rhs, + origintype, + origin, + _local, + modifiable, + removable, + ) end function SCIProwFree(row, blkmem, set, lp) - ccall((:SCIProwFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROW}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), row, blkmem, set, lp) + ccall( + (:SCIProwFree, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_ROW}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), + row, + blkmem, + set, + lp, + ) end function SCIProwPrint(row, messagehdlr, file) - ccall((:SCIProwPrint, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), row, messagehdlr, file) + ccall( + (:SCIProwPrint, libscip), + Cvoid, + (Ptr{SCIP_ROW}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), + row, + messagehdlr, + file, + ) end function SCIProwEnsureSize(row, blkmem, set, num) - ccall((:SCIProwEnsureSize, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), row, blkmem, set, num) + ccall( + (:SCIProwEnsureSize, libscip), + SCIP_RETCODE, + (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), + row, + blkmem, + set, + num, + ) end function SCIProwCapture(row) @@ -11094,7 +30961,15 @@ function SCIProwCapture(row) end function SCIProwRelease(row, blkmem, set, lp) - ccall((:SCIProwRelease, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROW}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), row, blkmem, set, lp) + ccall( + (:SCIProwRelease, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_ROW}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), + row, + blkmem, + set, + lp, + ) end function SCIProwDelaySort(row) @@ -11102,207 +30977,820 @@ function SCIProwDelaySort(row) end function SCIProwForceSort(row, set) - ccall((:SCIProwForceSort, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) + ccall( + (:SCIProwForceSort, libscip), + Cvoid, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), + row, + set, + ) end function SCIProwAddCoef(row, blkmem, set, eventqueue, lp, col, val) - ccall((:SCIProwAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_COL}, Cdouble), row, blkmem, set, eventqueue, lp, col, val) + ccall( + (:SCIProwAddCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Ptr{SCIP_COL}, + Cdouble, + ), + row, + blkmem, + set, + eventqueue, + lp, + col, + val, + ) end function SCIProwDelCoef(row, blkmem, set, eventqueue, lp, col) - ccall((:SCIProwDelCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_COL}), row, blkmem, set, eventqueue, lp, col) + ccall( + (:SCIProwDelCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Ptr{SCIP_COL}, + ), + row, + blkmem, + set, + eventqueue, + lp, + col, + ) end function SCIProwChgCoef(row, blkmem, set, eventqueue, lp, col, val) - ccall((:SCIProwChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_COL}, Cdouble), row, blkmem, set, eventqueue, lp, col, val) + ccall( + (:SCIProwChgCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Ptr{SCIP_COL}, + Cdouble, + ), + row, + blkmem, + set, + eventqueue, + lp, + col, + val, + ) end function SCIProwIncCoef(row, blkmem, set, eventqueue, lp, col, incval) - ccall((:SCIProwIncCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Ptr{SCIP_COL}, Cdouble), row, blkmem, set, eventqueue, lp, col, incval) + ccall( + (:SCIProwIncCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Ptr{SCIP_COL}, + Cdouble, + ), + row, + blkmem, + set, + eventqueue, + lp, + col, + incval, + ) end function SCIProwChgConstant(row, blkmem, set, stat, eventqueue, lp, constant) - ccall((:SCIProwChgConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Cdouble), row, blkmem, set, stat, eventqueue, lp, constant) + ccall( + (:SCIProwChgConstant, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Cdouble, + ), + row, + blkmem, + set, + stat, + eventqueue, + lp, + constant, + ) end function SCIProwAddConstant(row, blkmem, set, stat, eventqueue, lp, addval) - ccall((:SCIProwAddConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Cdouble), row, blkmem, set, stat, eventqueue, lp, addval) + ccall( + (:SCIProwAddConstant, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Cdouble, + ), + row, + blkmem, + set, + stat, + eventqueue, + lp, + addval, + ) end function SCIProwChgLhs(row, blkmem, set, eventqueue, lp, lhs) - ccall((:SCIProwChgLhs, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Cdouble), row, blkmem, set, eventqueue, lp, lhs) + ccall( + (:SCIProwChgLhs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Cdouble, + ), + row, + blkmem, + set, + eventqueue, + lp, + lhs, + ) end function SCIProwChgRhs(row, blkmem, set, eventqueue, lp, rhs) - ccall((:SCIProwChgRhs, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}, Cdouble), row, blkmem, set, eventqueue, lp, rhs) + ccall( + (:SCIProwChgRhs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + Cdouble, + ), + row, + blkmem, + set, + eventqueue, + lp, + rhs, + ) end function SCIProwChgLocal(row, _local) - ccall((:SCIProwChgLocal, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Cuint), row, _local) -end - -function SCIProwCalcIntegralScalar(row, set, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) - ccall((:SCIProwCalcIntegralScalar, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Cdouble, Cdouble, Clonglong, Cdouble, Cuint, Ptr{Cdouble}, Ptr{Cuint}), row, set, mindelta, maxdelta, maxdnom, maxscale, usecontvars, intscalar, success) -end - -function SCIProwMakeIntegral(row, blkmem, set, eventqueue, stat, lp, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) - ccall((:SCIProwMakeIntegral, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}, Cdouble, Cdouble, Clonglong, Cdouble, Cuint, Ptr{Cuint}), row, blkmem, set, eventqueue, stat, lp, mindelta, maxdelta, maxdnom, maxscale, usecontvars, success) + ccall( + (:SCIProwChgLocal, libscip), + SCIP_RETCODE, + (Ptr{SCIP_ROW}, Cuint), + row, + _local, + ) +end + +function SCIProwCalcIntegralScalar( + row, + set, + mindelta, + maxdelta, + maxdnom, + maxscale, + usecontvars, + intscalar, + success, +) + ccall( + (:SCIProwCalcIntegralScalar, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{SCIP_SET}, + Cdouble, + Cdouble, + Clonglong, + Cdouble, + Cuint, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + row, + set, + mindelta, + maxdelta, + maxdnom, + maxscale, + usecontvars, + intscalar, + success, + ) +end + +function SCIProwMakeIntegral( + row, + blkmem, + set, + eventqueue, + stat, + lp, + mindelta, + maxdelta, + maxdnom, + maxscale, + usecontvars, + success, +) + ccall( + (:SCIProwMakeIntegral, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_STAT}, + Ptr{SCIP_LP}, + Cdouble, + Cdouble, + Clonglong, + Cdouble, + Cuint, + Ptr{Cuint}, + ), + row, + blkmem, + set, + eventqueue, + stat, + lp, + mindelta, + maxdelta, + maxdnom, + maxscale, + usecontvars, + success, + ) end function SCIProwRecalcNorms(row, set) - ccall((:SCIProwRecalcNorms, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) + ccall( + (:SCIProwRecalcNorms, libscip), + Cvoid, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), + row, + set, + ) end function SCIProwRecalcLPActivity(row, stat) - ccall((:SCIProwRecalcLPActivity, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), row, stat) + ccall( + (:SCIProwRecalcLPActivity, libscip), + Cvoid, + (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), + row, + stat, + ) end function SCIProwGetLPActivity(row, set, stat, lp) - ccall((:SCIProwGetLPActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), row, set, stat, lp) + ccall( + (:SCIProwGetLPActivity, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), + row, + set, + stat, + lp, + ) end function SCIProwGetLPFeasibility(row, set, stat, lp) - ccall((:SCIProwGetLPFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), row, set, stat, lp) + ccall( + (:SCIProwGetLPFeasibility, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), + row, + set, + stat, + lp, + ) end function SCIProwGetRelaxFeasibility(row, set, stat) - ccall((:SCIProwGetRelaxFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwGetRelaxFeasibility, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwGetNLPFeasibility(row, set, stat) - ccall((:SCIProwGetNLPFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwGetNLPFeasibility, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwRecalcPseudoActivity(row, stat) - ccall((:SCIProwRecalcPseudoActivity, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), row, stat) + ccall( + (:SCIProwRecalcPseudoActivity, libscip), + Cvoid, + (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), + row, + stat, + ) end function SCIProwGetPseudoActivity(row, set, stat) - ccall((:SCIProwGetPseudoActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwGetPseudoActivity, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwGetPseudoFeasibility(row, set, stat) - ccall((:SCIProwGetPseudoFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwGetPseudoFeasibility, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwGetSolActivity(row, set, stat, sol) - ccall((:SCIProwGetSolActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), row, set, stat, sol) + ccall( + (:SCIProwGetSolActivity, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), + row, + set, + stat, + sol, + ) end function SCIProwGetSolFeasibility(row, set, stat, sol) - ccall((:SCIProwGetSolFeasibility, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), row, set, stat, sol) + ccall( + (:SCIProwGetSolFeasibility, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), + row, + set, + stat, + sol, + ) end function SCIProwGetMinActivity(row, set, stat) - ccall((:SCIProwGetMinActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwGetMinActivity, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwGetMaxActivity(row, set, stat) - ccall((:SCIProwGetMaxActivity, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwGetMaxActivity, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwIsRedundant(row, set, stat) - ccall((:SCIProwIsRedundant, libscip), Cuint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwIsRedundant, libscip), + Cuint, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwGetMaxval(row, set) - ccall((:SCIProwGetMaxval, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) + ccall( + (:SCIProwGetMaxval, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), + row, + set, + ) end function SCIProwGetMinval(row, set) - ccall((:SCIProwGetMinval, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) + ccall( + (:SCIProwGetMinval, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), + row, + set, + ) end function SCIProwGetMaxidx(row, set) - ccall((:SCIProwGetMaxidx, libscip), Cint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) + ccall( + (:SCIProwGetMaxidx, libscip), + Cint, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), + row, + set, + ) end function SCIProwGetMinidx(row, set) - ccall((:SCIProwGetMinidx, libscip), Cint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) + ccall( + (:SCIProwGetMinidx, libscip), + Cint, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), + row, + set, + ) end function SCIProwGetNumIntCols(row, set) - ccall((:SCIProwGetNumIntCols, libscip), Cint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) + ccall( + (:SCIProwGetNumIntCols, libscip), + Cint, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), + row, + set, + ) end function SCIProwGetNumImpliedIntCols(row, set) - ccall((:SCIProwGetNumImpliedIntCols, libscip), Cint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), row, set) + ccall( + (:SCIProwGetNumImpliedIntCols, libscip), + Cint, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}), + row, + set, + ) end function SCIProwGetLPSolCutoffDistance(row, set, stat, sol, lp) - ccall((:SCIProwGetLPSolCutoffDistance, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Ptr{SCIP_LP}), row, set, stat, sol, lp) + ccall( + (:SCIProwGetLPSolCutoffDistance, libscip), + Cdouble, + ( + Ptr{SCIP_ROW}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_SOL}, + Ptr{SCIP_LP}, + ), + row, + set, + stat, + sol, + lp, + ) end function SCIProwGetLPEfficacy(row, set, stat, lp) - ccall((:SCIProwGetLPEfficacy, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), row, set, stat, lp) + ccall( + (:SCIProwGetLPEfficacy, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}), + row, + set, + stat, + lp, + ) end function SCIProwIsLPEfficacious(row, set, stat, lp, root) - ccall((:SCIProwIsLPEfficacious, libscip), Cuint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}, Cuint), row, set, stat, lp, root) + ccall( + (:SCIProwIsLPEfficacious, libscip), + Cuint, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LP}, Cuint), + row, + set, + stat, + lp, + root, + ) end function SCIProwGetSolEfficacy(row, set, stat, sol) - ccall((:SCIProwGetSolEfficacy, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), row, set, stat, sol) + ccall( + (:SCIProwGetSolEfficacy, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}), + row, + set, + stat, + sol, + ) end function SCIProwIsSolEfficacious(row, set, stat, sol, root) - ccall((:SCIProwIsSolEfficacious, libscip), Cuint, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Cuint), row, set, stat, sol, root) + ccall( + (:SCIProwIsSolEfficacious, libscip), + Cuint, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Cuint), + row, + set, + stat, + sol, + root, + ) end function SCIProwGetRelaxEfficacy(row, set, stat) - ccall((:SCIProwGetRelaxEfficacy, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwGetRelaxEfficacy, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwGetNLPEfficacy(row, set, stat) - ccall((:SCIProwGetNLPEfficacy, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), row, set, stat) + ccall( + (:SCIProwGetNLPEfficacy, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + row, + set, + stat, + ) end function SCIProwGetObjParallelism(row, set, lp) - ccall((:SCIProwGetObjParallelism, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), row, set, lp) -end - -function SCIProwCatchEvent(row, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIProwCatchEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Ptr{Cint}), row, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) -end - -function SCIProwDropEvent(row, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) - ccall((:SCIProwDropEvent, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, SCIP_EVENTTYPE, Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTDATA}, Cint), row, blkmem, set, eventtype, eventhdlr, eventdata, filterpos) + ccall( + (:SCIProwGetObjParallelism, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), + row, + set, + lp, + ) +end + +function SCIProwCatchEvent( + row, + blkmem, + set, + eventtype, + eventhdlr, + eventdata, + filterpos, +) + ccall( + (:SCIProwCatchEvent, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + SCIP_EVENTTYPE, + Ptr{SCIP_EVENTHDLR}, + Ptr{SCIP_EVENTDATA}, + Ptr{Cint}, + ), + row, + blkmem, + set, + eventtype, + eventhdlr, + eventdata, + filterpos, + ) +end + +function SCIProwDropEvent( + row, + blkmem, + set, + eventtype, + eventhdlr, + eventdata, + filterpos, +) + ccall( + (:SCIProwDropEvent, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + SCIP_EVENTTYPE, + Ptr{SCIP_EVENTHDLR}, + Ptr{SCIP_EVENTDATA}, + Cint, + ), + row, + blkmem, + set, + eventtype, + eventhdlr, + eventdata, + filterpos, + ) end function SCIProwMarkNotRemovableLocal(row, stat) - ccall((:SCIProwMarkNotRemovableLocal, libscip), Cvoid, (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), row, stat) + ccall( + (:SCIProwMarkNotRemovableLocal, libscip), + Cvoid, + (Ptr{SCIP_ROW}, Ptr{SCIP_STAT}), + row, + stat, + ) end function SCIPlpCreate(lp, set, messagehdlr, stat, name) - ccall((:SCIPlpCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LP}}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{Cchar}), lp, set, messagehdlr, stat, name) + ccall( + (:SCIPlpCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_LP}}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{Cchar}, + ), + lp, + set, + messagehdlr, + stat, + name, + ) end function SCIPlpFree(lp, blkmem, set, eventqueue, eventfilter) - ccall((:SCIPlpFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LP}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, eventqueue, eventfilter) + ccall( + (:SCIPlpFree, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_LP}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + ), + lp, + blkmem, + set, + eventqueue, + eventfilter, + ) end function SCIPlpReset(lp, blkmem, set, prob, stat, eventqueue, eventfilter) - ccall((:SCIPlpReset, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, prob, stat, eventqueue, eventfilter) + ccall( + (:SCIPlpReset, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_PROB}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + ), + lp, + blkmem, + set, + prob, + stat, + eventqueue, + eventfilter, + ) end function SCIPlpAddCol(lp, set, col, depth) - ccall((:SCIPlpAddCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_COL}, Cint), lp, set, col, depth) + ccall( + (:SCIPlpAddCol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_COL}, Cint), + lp, + set, + col, + depth, + ) end function SCIPlpAddRow(lp, blkmem, set, eventqueue, eventfilter, row, depth) - ccall((:SCIPlpAddRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_ROW}, Cint), lp, blkmem, set, eventqueue, eventfilter, row, depth) + ccall( + (:SCIPlpAddRow, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_ROW}, + Cint, + ), + lp, + blkmem, + set, + eventqueue, + eventfilter, + row, + depth, + ) end function SCIPlpShrinkCols(lp, set, newncols) - ccall((:SCIPlpShrinkCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Cint), lp, set, newncols) + ccall( + (:SCIPlpShrinkCols, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Cint), + lp, + set, + newncols, + ) end function SCIPlpShrinkRows(lp, blkmem, set, eventqueue, eventfilter, newnrows) - ccall((:SCIPlpShrinkRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Cint), lp, blkmem, set, eventqueue, eventfilter, newnrows) + ccall( + (:SCIPlpShrinkRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Cint, + ), + lp, + blkmem, + set, + eventqueue, + eventfilter, + newnrows, + ) end function SCIPlpClear(lp, blkmem, set, eventqueue, eventfilter) - ccall((:SCIPlpClear, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, eventqueue, eventfilter) + ccall( + (:SCIPlpClear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + ), + lp, + blkmem, + set, + eventqueue, + eventfilter, + ) end function SCIPlpMarkSize(lp) @@ -11310,63 +31798,216 @@ function SCIPlpMarkSize(lp) end function SCIPlpSetSizeMark(lp, nrows, ncols) - ccall((:SCIPlpSetSizeMark, libscip), Cvoid, (Ptr{SCIP_LP}, Cint, Cint), lp, nrows, ncols) + ccall( + (:SCIPlpSetSizeMark, libscip), + Cvoid, + (Ptr{SCIP_LP}, Cint, Cint), + lp, + nrows, + ncols, + ) end function SCIPlpGetBasisInd(lp, basisind) - ccall((:SCIPlpGetBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{Cint}), lp, basisind) + ccall( + (:SCIPlpGetBasisInd, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{Cint}), + lp, + basisind, + ) end function SCIPlpGetBase(lp, cstat, rstat) - ccall((:SCIPlpGetBase, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{Cint}, Ptr{Cint}), lp, cstat, rstat) + ccall( + (:SCIPlpGetBase, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{Cint}, Ptr{Cint}), + lp, + cstat, + rstat, + ) end function SCIPlpGetBInvRow(lp, r, coef, inds, ninds) - ccall((:SCIPlpGetBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lp, r, coef, inds, ninds) + ccall( + (:SCIPlpGetBInvRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + lp, + r, + coef, + inds, + ninds, + ) end function SCIPlpGetBInvCol(lp, c, coef, inds, ninds) - ccall((:SCIPlpGetBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lp, c, coef, inds, ninds) + ccall( + (:SCIPlpGetBInvCol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + lp, + c, + coef, + inds, + ninds, + ) end function SCIPlpGetBInvARow(lp, r, binvrow, coef, inds, ninds) - ccall((:SCIPlpGetBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lp, r, binvrow, coef, inds, ninds) + ccall( + (:SCIPlpGetBInvARow, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + lp, + r, + binvrow, + coef, + inds, + ninds, + ) end function SCIPlpGetBInvACol(lp, c, coef, inds, ninds) - ccall((:SCIPlpGetBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lp, c, coef, inds, ninds) + ccall( + (:SCIPlpGetBInvACol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + lp, + c, + coef, + inds, + ninds, + ) end function SCIPlpSumRows(lp, set, prob, weights, sumcoef, sumlhs, sumrhs) - ccall((:SCIPlpSumRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{Cdouble}, Ptr{SCIP_REALARRAY}, Ptr{Cdouble}, Ptr{Cdouble}), lp, set, prob, weights, sumcoef, sumlhs, sumrhs) + ccall( + (:SCIPlpSumRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{SCIP_SET}, + Ptr{SCIP_PROB}, + Ptr{Cdouble}, + Ptr{SCIP_REALARRAY}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + lp, + set, + prob, + weights, + sumcoef, + sumlhs, + sumrhs, + ) end function SCIPlpGetState(lp, blkmem, lpistate) - ccall((:SCIPlpGetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lp, blkmem, lpistate) -end - -function SCIPlpSetState(lp, blkmem, set, prob, eventqueue, lpistate, wasprimfeas, wasprimchecked, wasdualfeas, wasdualchecked) - ccall((:SCIPlpSetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPISTATE}, Cuint, Cuint, Cuint, Cuint), lp, blkmem, set, prob, eventqueue, lpistate, wasprimfeas, wasprimchecked, wasdualfeas, wasdualchecked) + ccall( + (:SCIPlpGetState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), + lp, + blkmem, + lpistate, + ) +end + +function SCIPlpSetState( + lp, + blkmem, + set, + prob, + eventqueue, + lpistate, + wasprimfeas, + wasprimchecked, + wasdualfeas, + wasdualchecked, +) + ccall( + (:SCIPlpSetState, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_PROB}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPISTATE}, + Cuint, + Cuint, + Cuint, + Cuint, + ), + lp, + blkmem, + set, + prob, + eventqueue, + lpistate, + wasprimfeas, + wasprimchecked, + wasdualfeas, + wasdualchecked, + ) end function SCIPlpFreeState(lp, blkmem, lpistate) - ccall((:SCIPlpFreeState, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lp, blkmem, lpistate) + ccall( + (:SCIPlpFreeState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), + lp, + blkmem, + lpistate, + ) end function SCIPlpInterrupt(lp, interrupt) - ccall((:SCIPlpInterrupt, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Cuint), lp, interrupt) + ccall( + (:SCIPlpInterrupt, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Cuint), + lp, + interrupt, + ) end function SCIPlpGetNorms(lp, blkmem, lpinorms) - ccall((:SCIPlpGetNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), lp, blkmem, lpinorms) + ccall( + (:SCIPlpGetNorms, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), + lp, + blkmem, + lpinorms, + ) end function SCIPlpSetNorms(lp, blkmem, lpinorms) - ccall((:SCIPlpSetNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPINORMS}), lp, blkmem, lpinorms) + ccall( + (:SCIPlpSetNorms, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPINORMS}), + lp, + blkmem, + lpinorms, + ) end function SCIPlpFreeNorms(lp, blkmem, lpinorms) - ccall((:SCIPlpFreeNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), lp, blkmem, lpinorms) + ccall( + (:SCIPlpFreeNorms, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), + lp, + blkmem, + lpinorms, + ) end function SCIPlpGetCutoffbound(lp) @@ -11374,7 +32015,15 @@ function SCIPlpGetCutoffbound(lp) end function SCIPlpSetCutoffbound(lp, set, prob, cutoffbound) - ccall((:SCIPlpSetCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Cdouble), lp, set, prob, cutoffbound) + ccall( + (:SCIPlpSetCutoffbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Cdouble), + lp, + set, + prob, + cutoffbound, + ) end function SCIPlpGetFeastol(lp) @@ -11382,23 +32031,105 @@ function SCIPlpGetFeastol(lp) end function SCIPlpSetFeastol(lp, set, newfeastol) - ccall((:SCIPlpSetFeastol, libscip), Cvoid, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Cdouble), lp, set, newfeastol) + ccall( + (:SCIPlpSetFeastol, libscip), + Cvoid, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Cdouble), + lp, + set, + newfeastol, + ) end function SCIPlpResetFeastol(lp, set) - ccall((:SCIPlpResetFeastol, libscip), Cvoid, (Ptr{SCIP_LP}, Ptr{SCIP_SET}), lp, set) + ccall( + (:SCIPlpResetFeastol, libscip), + Cvoid, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}), + lp, + set, + ) end function SCIPlpFlush(lp, blkmem, set, prob, eventqueue) - ccall((:SCIPlpFlush, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_EVENTQUEUE}), lp, blkmem, set, prob, eventqueue) + ccall( + (:SCIPlpFlush, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_PROB}, + Ptr{SCIP_EVENTQUEUE}, + ), + lp, + blkmem, + set, + prob, + eventqueue, + ) end function SCIPlpMarkFlushed(lp, set) - ccall((:SCIPlpMarkFlushed, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}), lp, set) -end - -function SCIPlpSolveAndEval(lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, itlim, limitresolveiters, aging, keepsol, forcedlpsolve, lperror) - ccall((:SCIPlpSolveAndEval, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_PROB}, Clonglong, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), lp, set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, itlim, limitresolveiters, aging, keepsol, forcedlpsolve, lperror) + ccall( + (:SCIPlpMarkFlushed, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}), + lp, + set, + ) +end + +function SCIPlpSolveAndEval( + lp, + set, + messagehdlr, + blkmem, + stat, + eventqueue, + eventfilter, + prob, + itlim, + limitresolveiters, + aging, + keepsol, + forcedlpsolve, + lperror, +) + ccall( + (:SCIPlpSolveAndEval, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_PROB}, + Clonglong, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + lp, + set, + messagehdlr, + blkmem, + stat, + eventqueue, + eventfilter, + prob, + itlim, + limitresolveiters, + aging, + keepsol, + forcedlpsolve, + lperror, + ) end function SCIPlpGetSolstat(lp) @@ -11406,7 +32137,13 @@ function SCIPlpGetSolstat(lp) end function SCIPlpSetRootLPIsRelax(lp, isrelax) - ccall((:SCIPlpSetRootLPIsRelax, libscip), Cvoid, (Ptr{SCIP_LP}, Cuint), lp, isrelax) + ccall( + (:SCIPlpSetRootLPIsRelax, libscip), + Cvoid, + (Ptr{SCIP_LP}, Cuint), + lp, + isrelax, + ) end function SCIPlpIsRootLPRelax(lp) @@ -11414,7 +32151,14 @@ function SCIPlpIsRootLPRelax(lp) end function SCIPlpGetObjval(lp, set, prob) - ccall((:SCIPlpGetObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) + ccall( + (:SCIPlpGetObjval, libscip), + Cdouble, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), + lp, + set, + prob, + ) end function SCIPlpGetColumnObjval(lp) @@ -11422,11 +32166,25 @@ function SCIPlpGetColumnObjval(lp) end function SCIPlpGetLooseObjval(lp, set, prob) - ccall((:SCIPlpGetLooseObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) + ccall( + (:SCIPlpGetLooseObjval, libscip), + Cdouble, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), + lp, + set, + prob, + ) end function SCIPlpStoreRootObjval(lp, set, prob) - ccall((:SCIPlpStoreRootObjval, libscip), Cvoid, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) + ccall( + (:SCIPlpStoreRootObjval, libscip), + Cvoid, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), + lp, + set, + prob, + ) end function SCIPlpInvalidateRootObjval(lp) @@ -11434,55 +32192,176 @@ function SCIPlpInvalidateRootObjval(lp) end function SCIPlpGetGlobalPseudoObjval(lp, set, prob) - ccall((:SCIPlpGetGlobalPseudoObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) + ccall( + (:SCIPlpGetGlobalPseudoObjval, libscip), + Cdouble, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), + lp, + set, + prob, + ) end function SCIPlpRecomputeLocalAndGlobalPseudoObjval(lp, set, prob) - ccall((:SCIPlpRecomputeLocalAndGlobalPseudoObjval, libscip), Cvoid, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) + ccall( + (:SCIPlpRecomputeLocalAndGlobalPseudoObjval, libscip), + Cvoid, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), + lp, + set, + prob, + ) end function SCIPlpGetPseudoObjval(lp, set, prob) - ccall((:SCIPlpGetPseudoObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), lp, set, prob) -end - -function SCIPlpGetModifiedPseudoObjval(lp, set, prob, var, oldbound, newbound, boundtype) - ccall((:SCIPlpGetModifiedPseudoObjval, libscip), Cdouble, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_VAR}, Cdouble, Cdouble, SCIP_BOUNDTYPE), lp, set, prob, var, oldbound, newbound, boundtype) + ccall( + (:SCIPlpGetPseudoObjval, libscip), + Cdouble, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), + lp, + set, + prob, + ) +end + +function SCIPlpGetModifiedPseudoObjval( + lp, + set, + prob, + var, + oldbound, + newbound, + boundtype, +) + ccall( + (:SCIPlpGetModifiedPseudoObjval, libscip), + Cdouble, + ( + Ptr{SCIP_LP}, + Ptr{SCIP_SET}, + Ptr{SCIP_PROB}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + SCIP_BOUNDTYPE, + ), + lp, + set, + prob, + var, + oldbound, + newbound, + boundtype, + ) end function SCIPlpUpdateVarObj(lp, set, var, oldobj, newobj) - ccall((:SCIPlpUpdateVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldobj, newobj) + ccall( + (:SCIPlpUpdateVarObj, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + lp, + set, + var, + oldobj, + newobj, + ) end function SCIPlpUpdateVarLbGlobal(lp, set, var, oldlb, newlb) - ccall((:SCIPlpUpdateVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldlb, newlb) + ccall( + (:SCIPlpUpdateVarLbGlobal, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + lp, + set, + var, + oldlb, + newlb, + ) end function SCIPlpUpdateVarLb(lp, set, var, oldlb, newlb) - ccall((:SCIPlpUpdateVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldlb, newlb) + ccall( + (:SCIPlpUpdateVarLb, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + lp, + set, + var, + oldlb, + newlb, + ) end function SCIPlpUpdateVarUbGlobal(lp, set, var, oldub, newub) - ccall((:SCIPlpUpdateVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldub, newub) + ccall( + (:SCIPlpUpdateVarUbGlobal, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + lp, + set, + var, + oldub, + newub, + ) end function SCIPlpUpdateVarUb(lp, set, var, oldub, newub) - ccall((:SCIPlpUpdateVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), lp, set, var, oldub, newub) + ccall( + (:SCIPlpUpdateVarUb, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + lp, + set, + var, + oldub, + newub, + ) end function SCIPlpUpdateAddVar(lp, set, var) - ccall((:SCIPlpUpdateAddVar, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lp, set, var) + ccall( + (:SCIPlpUpdateAddVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), + lp, + set, + var, + ) end function SCIPlpUpdateDelVar(lp, set, var) - ccall((:SCIPlpUpdateDelVar, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lp, set, var) + ccall( + (:SCIPlpUpdateDelVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), + lp, + set, + var, + ) end function SCIPlpUpdateVarColumn(lp, set, var) - ccall((:SCIPlpUpdateVarColumn, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lp, set, var) + ccall( + (:SCIPlpUpdateVarColumn, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), + lp, + set, + var, + ) end function SCIPlpUpdateVarLoose(lp, set, var) - ccall((:SCIPlpUpdateVarLoose, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lp, set, var) + ccall( + (:SCIPlpUpdateVarLoose, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), + lp, + set, + var, + ) end function SCIPlpDecNLoosevars(lp) @@ -11490,59 +32369,266 @@ function SCIPlpDecNLoosevars(lp) end function SCIPlpGetSol(lp, set, stat, primalfeasible, dualfeasible) - ccall((:SCIPlpGetSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}), lp, set, stat, primalfeasible, dualfeasible) + ccall( + (:SCIPlpGetSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}), + lp, + set, + stat, + primalfeasible, + dualfeasible, + ) end function SCIPlpGetUnboundedSol(lp, set, stat, primalfeasible, rayfeasible) - ccall((:SCIPlpGetUnboundedSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}), lp, set, stat, primalfeasible, rayfeasible) + ccall( + (:SCIPlpGetUnboundedSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}), + lp, + set, + stat, + primalfeasible, + rayfeasible, + ) end function SCIPlpGetPrimalRay(lp, set, ray) - ccall((:SCIPlpGetPrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cdouble}), lp, set, ray) + ccall( + (:SCIPlpGetPrimalRay, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cdouble}), + lp, + set, + ray, + ) end function SCIPlpGetDualfarkas(lp, set, stat, forcedlpsolve, valid) - ccall((:SCIPlpGetDualfarkas, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Cuint, Ptr{Cuint}), lp, set, stat, forcedlpsolve, valid) + ccall( + (:SCIPlpGetDualfarkas, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Cuint, Ptr{Cuint}), + lp, + set, + stat, + forcedlpsolve, + valid, + ) end function SCIPlpGetIterations(lp, iterations) - ccall((:SCIPlpGetIterations, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{Cint}), lp, iterations) + ccall( + (:SCIPlpGetIterations, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{Cint}), + lp, + iterations, + ) end function SCIPlpUpdateAges(lp, stat) - ccall((:SCIPlpUpdateAges, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_STAT}), lp, stat) -end - -function SCIPlpRemoveNewObsoletes(lp, blkmem, set, stat, eventqueue, eventfilter) - ccall((:SCIPlpRemoveNewObsoletes, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, stat, eventqueue, eventfilter) -end - -function SCIPlpRemoveAllObsoletes(lp, blkmem, set, stat, eventqueue, eventfilter) - ccall((:SCIPlpRemoveAllObsoletes, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, stat, eventqueue, eventfilter) + ccall( + (:SCIPlpUpdateAges, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_STAT}), + lp, + stat, + ) +end + +function SCIPlpRemoveNewObsoletes( + lp, + blkmem, + set, + stat, + eventqueue, + eventfilter, +) + ccall( + (:SCIPlpRemoveNewObsoletes, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + ), + lp, + blkmem, + set, + stat, + eventqueue, + eventfilter, + ) +end + +function SCIPlpRemoveAllObsoletes( + lp, + blkmem, + set, + stat, + eventqueue, + eventfilter, +) + ccall( + (:SCIPlpRemoveAllObsoletes, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + ), + lp, + blkmem, + set, + stat, + eventqueue, + eventfilter, + ) end function SCIPlpCleanupNew(lp, blkmem, set, stat, eventqueue, eventfilter, root) - ccall((:SCIPlpCleanupNew, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Cuint), lp, blkmem, set, stat, eventqueue, eventfilter, root) + ccall( + (:SCIPlpCleanupNew, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Cuint, + ), + lp, + blkmem, + set, + stat, + eventqueue, + eventfilter, + root, + ) end function SCIPlpCleanupAll(lp, blkmem, set, stat, eventqueue, eventfilter, root) - ccall((:SCIPlpCleanupAll, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Cuint), lp, blkmem, set, stat, eventqueue, eventfilter, root) -end - -function SCIPlpRemoveRedundantRows(lp, blkmem, set, stat, eventqueue, eventfilter) - ccall((:SCIPlpRemoveRedundantRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}), lp, blkmem, set, stat, eventqueue, eventfilter) + ccall( + (:SCIPlpCleanupAll, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Cuint, + ), + lp, + blkmem, + set, + stat, + eventqueue, + eventfilter, + root, + ) +end + +function SCIPlpRemoveRedundantRows( + lp, + blkmem, + set, + stat, + eventqueue, + eventfilter, +) + ccall( + (:SCIPlpRemoveRedundantRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + ), + lp, + blkmem, + set, + stat, + eventqueue, + eventfilter, + ) end function SCIPlpStartDive(lp, blkmem, set, stat) - ccall((:SCIPlpStartDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), lp, blkmem, set, stat) -end - -function SCIPlpEndDive(lp, blkmem, set, messagehdlr, stat, eventqueue, eventfilter, prob, vars, nvars) - ccall((:SCIPlpEndDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_PROB}, Ptr{Ptr{SCIP_VAR}}, Cint), lp, blkmem, set, messagehdlr, stat, eventqueue, eventfilter, prob, vars, nvars) + ccall( + (:SCIPlpStartDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + lp, + blkmem, + set, + stat, + ) +end + +function SCIPlpEndDive( + lp, + blkmem, + set, + messagehdlr, + stat, + eventqueue, + eventfilter, + prob, + vars, + nvars, +) + ccall( + (:SCIPlpEndDive, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_PROB}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + ), + lp, + blkmem, + set, + messagehdlr, + stat, + eventqueue, + eventfilter, + prob, + vars, + nvars, + ) end function SCIPlpRecordOldRowSideDive(lp, row, sidetype) - ccall((:SCIPlpRecordOldRowSideDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_ROW}, SCIP_SIDETYPE), lp, row, sidetype) + ccall( + (:SCIPlpRecordOldRowSideDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_ROW}, SCIP_SIDETYPE), + lp, + row, + sidetype, + ) end function SCIPlpStartProbing(lp) @@ -11554,7 +32640,12 @@ function SCIPlpEndProbing(lp) end function SCIPlpStartStrongbranchProbing(lp) - ccall((:SCIPlpStartStrongbranchProbing, libscip), Cvoid, (Ptr{SCIP_LP},), lp) + ccall( + (:SCIPlpStartStrongbranchProbing, libscip), + Cvoid, + (Ptr{SCIP_LP},), + lp, + ) end function SCIPlpEndStrongbranchProbing(lp) @@ -11562,31 +32653,144 @@ function SCIPlpEndStrongbranchProbing(lp) end function SCIPlpGetProvedLowerbound(lp, set, bound) - ccall((:SCIPlpGetProvedLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cdouble}), lp, set, bound) + ccall( + (:SCIPlpGetProvedLowerbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cdouble}), + lp, + set, + bound, + ) end function SCIPlpIsInfeasibilityProved(lp, set, proved) - ccall((:SCIPlpIsInfeasibilityProved, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cuint}), lp, set, proved) + ccall( + (:SCIPlpIsInfeasibilityProved, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{Cuint}), + lp, + set, + proved, + ) end function SCIPlpWrite(lp, fname) - ccall((:SCIPlpWrite, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{Cchar}), lp, fname) -end - -function SCIPlpWriteMip(lp, set, messagehdlr, fname, genericnames, origobj, objsense, objscale, objoffset, lazyconss) - ccall((:SCIPlpWriteMip, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cuint, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Cuint), lp, set, messagehdlr, fname, genericnames, origobj, objsense, objscale, objoffset, lazyconss) + ccall( + (:SCIPlpWrite, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LP}, Ptr{Cchar}), + lp, + fname, + ) +end + +function SCIPlpWriteMip( + lp, + set, + messagehdlr, + fname, + genericnames, + origobj, + objsense, + objscale, + objoffset, + lazyconss, +) + ccall( + (:SCIPlpWriteMip, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{Cchar}, + Cuint, + Cuint, + SCIP_OBJSENSE, + Cdouble, + Cdouble, + Cuint, + ), + lp, + set, + messagehdlr, + fname, + genericnames, + origobj, + objsense, + objscale, + objoffset, + lazyconss, + ) end function SCIPlpRecalculateObjSqrNorm(set, lp) - ccall((:SCIPlpRecalculateObjSqrNorm, libscip), Cvoid, (Ptr{SCIP_SET}, Ptr{SCIP_LP}), set, lp) -end - -function SCIPlpComputeRelIntPoint(set, messagehdlr, lp, prob, relaxrows, inclobjcutoff, timelimit, iterlimit, point, success) - ccall((:SCIPlpComputeRelIntPoint, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_LP}, Ptr{SCIP_PROB}, Cuint, Cuint, Cdouble, Cint, Ptr{Cdouble}, Ptr{Cuint}), set, messagehdlr, lp, prob, relaxrows, inclobjcutoff, timelimit, iterlimit, point, success) + ccall( + (:SCIPlpRecalculateObjSqrNorm, libscip), + Cvoid, + (Ptr{SCIP_SET}, Ptr{SCIP_LP}), + set, + lp, + ) +end + +function SCIPlpComputeRelIntPoint( + set, + messagehdlr, + lp, + prob, + relaxrows, + inclobjcutoff, + timelimit, + iterlimit, + point, + success, +) + ccall( + (:SCIPlpComputeRelIntPoint, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_LP}, + Ptr{SCIP_PROB}, + Cuint, + Cuint, + Cdouble, + Cint, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + set, + messagehdlr, + lp, + prob, + relaxrows, + inclobjcutoff, + timelimit, + iterlimit, + point, + success, + ) end function SCIPlpGetDualDegeneracy(lp, set, stat, degeneracy, varconsratio) - ccall((:SCIPlpGetDualDegeneracy, libscip), SCIP_RETCODE, (Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cdouble}, Ptr{Cdouble}), lp, set, stat, degeneracy, varconsratio) + ccall( + (:SCIPlpGetDualDegeneracy, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LP}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + lp, + set, + stat, + degeneracy, + varconsratio, + ) end function SCIPlpGetCols(lp) @@ -11598,7 +32802,13 @@ function SCIPlpGetNCols(lp) end function SCIPlpGetNUnfixedCols(lp, eps) - ccall((:SCIPlpGetNUnfixedCols, libscip), Cint, (Ptr{SCIP_LP}, Cdouble), lp, eps) + ccall( + (:SCIPlpGetNUnfixedCols, libscip), + Cint, + (Ptr{SCIP_LP}, Cdouble), + lp, + eps, + ) end function SCIPlpGetRows(lp) @@ -11690,23 +32900,63 @@ function SCIPlpDivingRowsChanged(lp) end function SCIPlpIsFeasEQ(set, lp, val1, val2) - ccall((:SCIPlpIsFeasEQ, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) + ccall( + (:SCIPlpIsFeasEQ, libscip), + Cuint, + (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), + set, + lp, + val1, + val2, + ) end function SCIPlpIsFeasLT(set, lp, val1, val2) - ccall((:SCIPlpIsFeasLT, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) + ccall( + (:SCIPlpIsFeasLT, libscip), + Cuint, + (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), + set, + lp, + val1, + val2, + ) end function SCIPlpIsFeasLE(set, lp, val1, val2) - ccall((:SCIPlpIsFeasLE, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) + ccall( + (:SCIPlpIsFeasLE, libscip), + Cuint, + (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), + set, + lp, + val1, + val2, + ) end function SCIPlpIsFeasGT(set, lp, val1, val2) - ccall((:SCIPlpIsFeasGT, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) + ccall( + (:SCIPlpIsFeasGT, libscip), + Cuint, + (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), + set, + lp, + val1, + val2, + ) end function SCIPlpIsFeasGE(set, lp, val1, val2) - ccall((:SCIPlpIsFeasGE, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), set, lp, val1, val2) + ccall( + (:SCIPlpIsFeasGE, libscip), + Cuint, + (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble, Cdouble), + set, + lp, + val1, + val2, + ) end function SCIPlpIsFeasZero(lp, val) @@ -11714,115 +32964,306 @@ function SCIPlpIsFeasZero(lp, val) end function SCIPlpIsFeasPositive(lp, val) - ccall((:SCIPlpIsFeasPositive, libscip), Cuint, (Ptr{SCIP_LP}, Cdouble), lp, val) + ccall( + (:SCIPlpIsFeasPositive, libscip), + Cuint, + (Ptr{SCIP_LP}, Cdouble), + lp, + val, + ) end function SCIPlpIsFeasNegative(lp, val) - ccall((:SCIPlpIsFeasNegative, libscip), Cuint, (Ptr{SCIP_LP}, Cdouble), lp, val) + ccall( + (:SCIPlpIsFeasNegative, libscip), + Cuint, + (Ptr{SCIP_LP}, Cdouble), + lp, + val, + ) end function SCIPrationalCreate(rational) - ccall((:SCIPrationalCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONAL}},), rational) + ccall( + (:SCIPrationalCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_RATIONAL}},), + rational, + ) end function SCIPrationalCreateBuffer(bufmem, rational) - ccall((:SCIPrationalCreateBuffer, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}), bufmem, rational) + ccall( + (:SCIPrationalCreateBuffer, libscip), + SCIP_RETCODE, + (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}), + bufmem, + rational, + ) end function SCIPrationalCreateBlock(blkmem, rational) - ccall((:SCIPrationalCreateBlock, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}), blkmem, rational) + ccall( + (:SCIPrationalCreateBlock, libscip), + SCIP_RETCODE, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}), + blkmem, + rational, + ) end function SCIPrationalCopy(result, src) - ccall((:SCIPrationalCopy, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), result, src) + ccall( + (:SCIPrationalCopy, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), + result, + src, + ) end function SCIPrationalCopyBlock(mem, result, src) - ccall((:SCIPrationalCopyBlock, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), mem, result, src) + ccall( + (:SCIPrationalCopyBlock, libscip), + SCIP_RETCODE, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), + mem, + result, + src, + ) end function SCIPrationalCopyBuffer(bufmem, result, src) - ccall((:SCIPrationalCopyBuffer, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), bufmem, result, src) + ccall( + (:SCIPrationalCopyBuffer, libscip), + SCIP_RETCODE, + (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}), + bufmem, + result, + src, + ) end function SCIPrationalCreateArray(rational, size) - ccall((:SCIPrationalCreateArray, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), rational, size) + ccall( + (:SCIPrationalCreateArray, libscip), + SCIP_RETCODE, + (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), + rational, + size, + ) end function SCIPrationalCreateBlockArray(mem, rational, size) - ccall((:SCIPrationalCreateBlockArray, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), mem, rational, size) + ccall( + (:SCIPrationalCreateBlockArray, libscip), + SCIP_RETCODE, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), + mem, + rational, + size, + ) end function SCIPrationalCreateBufferArray(mem, rational, size) - ccall((:SCIPrationalCreateBufferArray, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), mem, rational, size) + ccall( + (:SCIPrationalCreateBufferArray, libscip), + SCIP_RETCODE, + (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), + mem, + rational, + size, + ) end function SCIPrationalCopyArray(target, src, len) - ccall((:SCIPrationalCopyArray, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint), target, src, len) + ccall( + (:SCIPrationalCopyArray, libscip), + SCIP_RETCODE, + (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint), + target, + src, + len, + ) end function SCIPrationalCopyBlockArray(mem, target, src, len) - ccall((:SCIPrationalCopyBlockArray, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint), mem, target, src, len) + ccall( + (:SCIPrationalCopyBlockArray, libscip), + SCIP_RETCODE, + ( + Ptr{BMS_BLKMEM}, + Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Cint, + ), + mem, + target, + src, + len, + ) end function SCIPrationalCopyBufferArray(mem, result, src, len) - ccall((:SCIPrationalCopyBufferArray, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Ptr{Ptr{SCIP_RATIONAL}}, Cint), mem, result, src, len) + ccall( + (:SCIPrationalCopyBufferArray, libscip), + SCIP_RETCODE, + ( + Ptr{BMS_BUFMEM}, + Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Cint, + ), + mem, + result, + src, + len, + ) end function SCIPrationalReallocArray(result, oldlen, newlen) - ccall((:SCIPrationalReallocArray, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), result, oldlen, newlen) + ccall( + (:SCIPrationalReallocArray, libscip), + SCIP_RETCODE, + (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), + result, + oldlen, + newlen, + ) end function SCIPrationalReallocBufferArray(mem, result, oldlen, newlen) - ccall((:SCIPrationalReallocBufferArray, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), mem, result, oldlen, newlen) + ccall( + (:SCIPrationalReallocBufferArray, libscip), + SCIP_RETCODE, + (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), + mem, + result, + oldlen, + newlen, + ) end function SCIPrationalReallocBlockArray(mem, result, oldlen, newlen) - ccall((:SCIPrationalReallocBlockArray, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), mem, result, oldlen, newlen) + ccall( + (:SCIPrationalReallocBlockArray, libscip), + SCIP_RETCODE, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint, Cint), + mem, + result, + oldlen, + newlen, + ) end function SCIPrationalFree(rational) - ccall((:SCIPrationalFree, libscip), Cvoid, (Ptr{Ptr{SCIP_RATIONAL}},), rational) + ccall( + (:SCIPrationalFree, libscip), + Cvoid, + (Ptr{Ptr{SCIP_RATIONAL}},), + rational, + ) end function SCIPrationalFreeBlock(mem, rational) - ccall((:SCIPrationalFreeBlock, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}), mem, rational) + ccall( + (:SCIPrationalFreeBlock, libscip), + Cvoid, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}), + mem, + rational, + ) end function SCIPrationalFreeBuffer(bufmem, rational) - ccall((:SCIPrationalFreeBuffer, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}), bufmem, rational) + ccall( + (:SCIPrationalFreeBuffer, libscip), + Cvoid, + (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}), + bufmem, + rational, + ) end function SCIPrationalFreeArray(ratarray, size) - ccall((:SCIPrationalFreeArray, libscip), Cvoid, (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), ratarray, size) + ccall( + (:SCIPrationalFreeArray, libscip), + Cvoid, + (Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), + ratarray, + size, + ) end function SCIPrationalFreeBlockArray(mem, ratblockarray, size) - ccall((:SCIPrationalFreeBlockArray, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), mem, ratblockarray, size) + ccall( + (:SCIPrationalFreeBlockArray, libscip), + Cvoid, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), + mem, + ratblockarray, + size, + ) end function SCIPrationalFreeBufferArray(mem, ratbufarray, size) - ccall((:SCIPrationalFreeBufferArray, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), mem, ratbufarray, size) + ccall( + (:SCIPrationalFreeBufferArray, libscip), + Cvoid, + (Ptr{BMS_BUFMEM}, Ptr{Ptr{Ptr{SCIP_RATIONAL}}}, Cint), + mem, + ratbufarray, + size, + ) end function SCIPrationalSetRational(res, src) - ccall((:SCIPrationalSetRational, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, src) + ccall( + (:SCIPrationalSetRational, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + src, + ) end function SCIPrationalSetFraction(res, nom, denom) - ccall((:SCIPrationalSetFraction, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Clonglong, Clonglong), res, nom, denom) + ccall( + (:SCIPrationalSetFraction, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Clonglong, Clonglong), + res, + nom, + denom, + ) end function SCIPrationalSetReal(res, real) - ccall((:SCIPrationalSetReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Cdouble), res, real) + ccall( + (:SCIPrationalSetReal, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Cdouble), + res, + real, + ) end function SCIPrationalSetInfinity(res) - ccall((:SCIPrationalSetInfinity, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), res) + ccall( + (:SCIPrationalSetInfinity, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL},), + res, + ) end function SCIPrationalSetNegInfinity(res) - ccall((:SCIPrationalSetNegInfinity, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), res) + ccall( + (:SCIPrationalSetNegInfinity, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL},), + res, + ) end function SCIPrationalIsString(desc) @@ -11830,187 +33271,472 @@ function SCIPrationalIsString(desc) end function SCIPrationalSetString(res, desc) - ccall((:SCIPrationalSetString, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{Cchar}), res, desc) + ccall( + (:SCIPrationalSetString, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{Cchar}), + res, + desc, + ) end function SCIPrationalCreateString(mem, rational, desc) - ccall((:SCIPrationalCreateString, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Cchar}), mem, rational, desc) + ccall( + (:SCIPrationalCreateString, libscip), + SCIP_RETCODE, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{Cchar}), + mem, + rational, + desc, + ) end function SCIPstrToRationalValue(desc, value, endptr) - ccall((:SCIPstrToRationalValue, libscip), Cuint, (Ptr{Cchar}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{Cchar}}), desc, value, endptr) + ccall( + (:SCIPstrToRationalValue, libscip), + Cuint, + (Ptr{Cchar}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{Cchar}}), + desc, + value, + endptr, + ) end function SCIPrationalResetFloatingPointRepresentable(rat) - ccall((:SCIPrationalResetFloatingPointRepresentable, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), rat) + ccall( + (:SCIPrationalResetFloatingPointRepresentable, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL},), + rat, + ) end function SCIPrationalCanonicalize(rational) - ccall((:SCIPrationalCanonicalize, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalCanonicalize, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalCheckInfByValue(rational) - ccall((:SCIPrationalCheckInfByValue, libscip), Cvoid, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalCheckInfByValue, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalAdd(res, op1, op2) - ccall((:SCIPrationalAdd, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) + ccall( + (:SCIPrationalAdd, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op1, + op2, + ) end function SCIPrationalAddReal(res, rat, real) - ccall((:SCIPrationalAddReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, rat, real) + ccall( + (:SCIPrationalAddReal, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), + res, + rat, + real, + ) end function SCIPrationalDiff(res, op1, op2) - ccall((:SCIPrationalDiff, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) + ccall( + (:SCIPrationalDiff, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op1, + op2, + ) end function SCIPrationalDiffReal(res, rat, real) - ccall((:SCIPrationalDiffReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, rat, real) + ccall( + (:SCIPrationalDiffReal, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), + res, + rat, + real, + ) end function SCIPrationalRelDiff(res, val1, val2) - ccall((:SCIPrationalRelDiff, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, val1, val2) + ccall( + (:SCIPrationalRelDiff, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + val1, + val2, + ) end function SCIPrationalMult(res, op1, op2) - ccall((:SCIPrationalMult, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) + ccall( + (:SCIPrationalMult, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op1, + op2, + ) end function SCIPrationalMultReal(res, op1, op2) - ccall((:SCIPrationalMultReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, op1, op2) + ccall( + (:SCIPrationalMultReal, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), + res, + op1, + op2, + ) end function SCIPrationalDiv(res, op1, op2) - ccall((:SCIPrationalDiv, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) + ccall( + (:SCIPrationalDiv, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op1, + op2, + ) end function SCIPrationalDivReal(res, op1, op2) - ccall((:SCIPrationalDivReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, op1, op2) + ccall( + (:SCIPrationalDivReal, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), + res, + op1, + op2, + ) end function SCIPrationalAddProd(res, op1, op2) - ccall((:SCIPrationalAddProd, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) + ccall( + (:SCIPrationalAddProd, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op1, + op2, + ) end function SCIPrationalAddProdReal(res, op1, op2) - ccall((:SCIPrationalAddProdReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, op1, op2) + ccall( + (:SCIPrationalAddProdReal, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), + res, + op1, + op2, + ) end function SCIPrationalDiffProd(res, op1, op2) - ccall((:SCIPrationalDiffProd, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) + ccall( + (:SCIPrationalDiffProd, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op1, + op2, + ) end function SCIPrationalDiffProdReal(res, op1, op2) - ccall((:SCIPrationalDiffProdReal, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), res, op1, op2) + ccall( + (:SCIPrationalDiffProdReal, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cdouble), + res, + op1, + op2, + ) end function SCIPrationalNegate(res, op) - ccall((:SCIPrationalNegate, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op) + ccall( + (:SCIPrationalNegate, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op, + ) end function SCIPrationalAbs(res, op) - ccall((:SCIPrationalAbs, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op) + ccall( + (:SCIPrationalAbs, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op, + ) end function SCIPrationalInvert(res, op) - ccall((:SCIPrationalInvert, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op) + ccall( + (:SCIPrationalInvert, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op, + ) end function SCIPrationalMin(res, op1, op2) - ccall((:SCIPrationalMin, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) + ccall( + (:SCIPrationalMin, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op1, + op2, + ) end function SCIPrationalMax(res, op1, op2) - ccall((:SCIPrationalMax, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, op1, op2) + ccall( + (:SCIPrationalMax, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + op1, + op2, + ) end function SCIPrationalIsEQ(rat1, rat2) - ccall((:SCIPrationalIsEQ, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) + ccall( + (:SCIPrationalIsEQ, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + rat1, + rat2, + ) end function SCIPrationalIsAbsEQ(rat1, rat2) - ccall((:SCIPrationalIsAbsEQ, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) + ccall( + (:SCIPrationalIsAbsEQ, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + rat1, + rat2, + ) end function SCIPrationalIsEQReal(rat, real) - ccall((:SCIPrationalIsEQReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) + ccall( + (:SCIPrationalIsEQReal, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Cdouble), + rat, + real, + ) end function SCIPrationalIsApproxEQReal(set, rat, real, roundmode) - ccall((:SCIPrationalIsApproxEQReal, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}, Cdouble, SCIP_ROUNDMODE_RAT), set, rat, real, roundmode) + ccall( + (:SCIPrationalIsApproxEQReal, libscip), + Cuint, + (Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}, Cdouble, SCIP_ROUNDMODE_RAT), + set, + rat, + real, + roundmode, + ) end function SCIPrationalIsGT(rat1, rat2) - ccall((:SCIPrationalIsGT, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) + ccall( + (:SCIPrationalIsGT, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + rat1, + rat2, + ) end function SCIPrationalIsLT(rat1, rat2) - ccall((:SCIPrationalIsLT, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) + ccall( + (:SCIPrationalIsLT, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + rat1, + rat2, + ) end function SCIPrationalIsGE(rat1, rat2) - ccall((:SCIPrationalIsGE, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) + ccall( + (:SCIPrationalIsGE, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + rat1, + rat2, + ) end function SCIPrationalIsLE(rat1, rat2) - ccall((:SCIPrationalIsLE, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) + ccall( + (:SCIPrationalIsLE, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + rat1, + rat2, + ) end function SCIPrationalIsAbsGT(rat1, rat2) - ccall((:SCIPrationalIsAbsGT, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), rat1, rat2) + ccall( + (:SCIPrationalIsAbsGT, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + rat1, + rat2, + ) end function SCIPrationalIsGTReal(rat, real) - ccall((:SCIPrationalIsGTReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) + ccall( + (:SCIPrationalIsGTReal, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Cdouble), + rat, + real, + ) end function SCIPrationalIsLTReal(rat, real) - ccall((:SCIPrationalIsLTReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) + ccall( + (:SCIPrationalIsLTReal, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Cdouble), + rat, + real, + ) end function SCIPrationalIsGEReal(rat, real) - ccall((:SCIPrationalIsGEReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) + ccall( + (:SCIPrationalIsGEReal, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Cdouble), + rat, + real, + ) end function SCIPrationalIsLEReal(rat, real) - ccall((:SCIPrationalIsLEReal, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Cdouble), rat, real) + ccall( + (:SCIPrationalIsLEReal, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Cdouble), + rat, + real, + ) end function SCIPrationalIsZero(rational) - ccall((:SCIPrationalIsZero, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalIsZero, libscip), + Cuint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalIsPositive(rational) - ccall((:SCIPrationalIsPositive, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalIsPositive, libscip), + Cuint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalIsNegative(rational) - ccall((:SCIPrationalIsNegative, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalIsNegative, libscip), + Cuint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalIsInfinity(rational) - ccall((:SCIPrationalIsInfinity, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalIsInfinity, libscip), + Cuint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalIsNegInfinity(rational) - ccall((:SCIPrationalIsNegInfinity, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalIsNegInfinity, libscip), + Cuint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalIsAbsInfinity(rational) - ccall((:SCIPrationalIsAbsInfinity, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalIsAbsInfinity, libscip), + Cuint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalIsIntegral(rational) - ccall((:SCIPrationalIsIntegral, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalIsIntegral, libscip), + Cuint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalIsFpRepresentable(rational) - ccall((:SCIPrationalIsFpRepresentable, libscip), Cuint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalIsFpRepresentable, libscip), + Cuint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalToString(rational, str, strlen) - ccall((:SCIPrationalToString, libscip), Cint, (Ptr{SCIP_RATIONAL}, Ptr{Cchar}, Cint), rational, str, strlen) + ccall( + (:SCIPrationalToString, libscip), + Cint, + (Ptr{SCIP_RATIONAL}, Ptr{Cchar}, Cint), + rational, + str, + strlen, + ) end function SCIPrationalStrLen(rational) @@ -12018,11 +33744,31 @@ function SCIPrationalStrLen(rational) end function SCIPrationalMessage(msg, file, rational) - ccall((:SCIPrationalMessage, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Ptr{SCIP_RATIONAL}), msg, file, rational) + ccall( + (:SCIPrationalMessage, libscip), + Cvoid, + (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Ptr{SCIP_RATIONAL}), + msg, + file, + rational, + ) end function SCIPrationalPrintVerbInfo(msg, verblevel, msgverblevel, rational) - ccall((:SCIPrationalPrintVerbInfo, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, SCIP_VERBLEVEL, SCIP_VERBLEVEL, Ptr{SCIP_RATIONAL}), msg, verblevel, msgverblevel, rational) + ccall( + (:SCIPrationalPrintVerbInfo, libscip), + Cvoid, + ( + Ptr{SCIP_MESSAGEHDLR}, + SCIP_VERBLEVEL, + SCIP_VERBLEVEL, + Ptr{SCIP_RATIONAL}, + ), + msg, + verblevel, + msgverblevel, + rational, + ) end function SCIPrationalPrint(rational) @@ -12030,83 +33776,208 @@ function SCIPrationalPrint(rational) end function SCIPrationalNumerator(rational) - ccall((:SCIPrationalNumerator, libscip), Clonglong, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalNumerator, libscip), + Clonglong, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalDenominator(rational) - ccall((:SCIPrationalDenominator, libscip), Clonglong, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalDenominator, libscip), + Clonglong, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalDenominatorIsLE(rational, val) - ccall((:SCIPrationalDenominatorIsLE, libscip), Cuint, (Ptr{SCIP_RATIONAL}, Clonglong), rational, val) + ccall( + (:SCIPrationalDenominatorIsLE, libscip), + Cuint, + (Ptr{SCIP_RATIONAL}, Clonglong), + rational, + val, + ) end function SCIPrationalGetSign(rational) - ccall((:SCIPrationalGetSign, libscip), Cint, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalGetSign, libscip), + Cint, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalGetFrac(res, src) - ccall((:SCIPrationalGetFrac, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), res, src) + ccall( + (:SCIPrationalGetFrac, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + res, + src, + ) end function SCIPrationalGetReal(rational) - ccall((:SCIPrationalGetReal, libscip), Cdouble, (Ptr{SCIP_RATIONAL},), rational) + ccall( + (:SCIPrationalGetReal, libscip), + Cdouble, + (Ptr{SCIP_RATIONAL},), + rational, + ) end function SCIPrationalRoundReal(rational, roundmode) - ccall((:SCIPrationalRoundReal, libscip), Cdouble, (Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), rational, roundmode) + ccall( + (:SCIPrationalRoundReal, libscip), + Cdouble, + (Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), + rational, + roundmode, + ) end function SCIPrationalRoundInteger(res, src, roundmode) - ccall((:SCIPrationalRoundInteger, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), res, src, roundmode) + ccall( + (:SCIPrationalRoundInteger, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), + res, + src, + roundmode, + ) end function SCIPrationalRoundLong(res, src, roundmode) - ccall((:SCIPrationalRoundLong, libscip), Cuint, (Ptr{Clonglong}, Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), res, src, roundmode) + ccall( + (:SCIPrationalRoundLong, libscip), + Cuint, + (Ptr{Clonglong}, Ptr{SCIP_RATIONAL}, SCIP_ROUNDMODE_RAT), + res, + src, + roundmode, + ) end function SCIPrationalComputeApproximation(res, src, maxdenom, forcegreater) - ccall((:SCIPrationalComputeApproximation, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Clonglong, Cint), res, src, maxdenom, forcegreater) + ccall( + (:SCIPrationalComputeApproximation, libscip), + Cvoid, + (Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Clonglong, Cint), + res, + src, + maxdenom, + forcegreater, + ) end function SCIPrationalarrayCreate(rationalarray, blkmem) - ccall((:SCIPrationalarrayCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONALARRAY}}, Ptr{BMS_BLKMEM}), rationalarray, blkmem) + ccall( + (:SCIPrationalarrayCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_RATIONALARRAY}}, Ptr{BMS_BLKMEM}), + rationalarray, + blkmem, + ) end function SCIPrationalarrayResize(rationalarray, newsize) - ccall((:SCIPrationalarrayResize, libscip), SCIP_RETCODE, (Ptr{SCIP_RATIONALARRAY}, Cint), rationalarray, newsize) + ccall( + (:SCIPrationalarrayResize, libscip), + SCIP_RETCODE, + (Ptr{SCIP_RATIONALARRAY}, Cint), + rationalarray, + newsize, + ) end function SCIPrationalarrayCopy(rationalarray, blkmem, sourcerationalarray) - ccall((:SCIPrationalarrayCopy, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONALARRAY}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_RATIONALARRAY}), rationalarray, blkmem, sourcerationalarray) + ccall( + (:SCIPrationalarrayCopy, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_RATIONALARRAY}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_RATIONALARRAY}, + ), + rationalarray, + blkmem, + sourcerationalarray, + ) end function SCIPrationalarrayFree(rationalarray, blkmem) - ccall((:SCIPrationalarrayFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_RATIONALARRAY}}, Ptr{BMS_BLKMEM}), rationalarray, blkmem) + ccall( + (:SCIPrationalarrayFree, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_RATIONALARRAY}}, Ptr{BMS_BLKMEM}), + rationalarray, + blkmem, + ) end function SCIPrationalarrayGetVal(rationalarray, idx, result) - ccall((:SCIPrationalarrayGetVal, libscip), Cvoid, (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), rationalarray, idx, result) + ccall( + (:SCIPrationalarrayGetVal, libscip), + Cvoid, + (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), + rationalarray, + idx, + result, + ) end function SCIPrationalarraySetVal(rationalarray, idx, val) - ccall((:SCIPrationalarraySetVal, libscip), SCIP_RETCODE, (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), rationalarray, idx, val) + ccall( + (:SCIPrationalarraySetVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), + rationalarray, + idx, + val, + ) end function SCIPrationalarrayIncVal(rationalarray, idx, incval) - ccall((:SCIPrationalarrayIncVal, libscip), SCIP_RETCODE, (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), rationalarray, idx, incval) + ccall( + (:SCIPrationalarrayIncVal, libscip), + SCIP_RETCODE, + (Ptr{SCIP_RATIONALARRAY}, Cint, Ptr{SCIP_RATIONAL}), + rationalarray, + idx, + incval, + ) end function SCIPrationalarrayPrint(rationalarray) - ccall((:SCIPrationalarrayPrint, libscip), SCIP_RETCODE, (Ptr{SCIP_RATIONALARRAY},), rationalarray) + ccall( + (:SCIPrationalarrayPrint, libscip), + SCIP_RETCODE, + (Ptr{SCIP_RATIONALARRAY},), + rationalarray, + ) end function SCIPrationalarrayGetMinIdx(rationalarray) - ccall((:SCIPrationalarrayGetMinIdx, libscip), Cint, (Ptr{SCIP_RATIONALARRAY},), rationalarray) + ccall( + (:SCIPrationalarrayGetMinIdx, libscip), + Cint, + (Ptr{SCIP_RATIONALARRAY},), + rationalarray, + ) end function SCIPrationalarrayGetMaxIdx(rationalarray) - ccall((:SCIPrationalarrayGetMaxIdx, libscip), Cint, (Ptr{SCIP_RATIONALARRAY},), rationalarray) + ccall( + (:SCIPrationalarrayGetMaxIdx, libscip), + Cint, + (Ptr{SCIP_RATIONALARRAY},), + rationalarray, + ) end function SCIPrationalChgInfinity(inf) @@ -12117,44 +33988,202 @@ function SCIPrationalGetInfinity() ccall((:SCIPrationalGetInfinity, libscip), Cdouble, ()) end -function SCIPcolExactCreate(col, fpcol, blkmem, set, stat, var, len, rows, vals, removable) - ccall((:SCIPcolExactCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COLEXACT}}, Ptr{SCIP_COL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{Ptr{SCIP_RATIONAL}}, Cuint), col, fpcol, blkmem, set, stat, var, len, rows, vals, removable) +function SCIPcolExactCreate( + col, + fpcol, + blkmem, + set, + stat, + var, + len, + rows, + vals, + removable, +) + ccall( + (:SCIPcolExactCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_COLEXACT}}, + Ptr{SCIP_COL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_VAR}, + Cint, + Ptr{Ptr{SCIP_ROWEXACT}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Cuint, + ), + col, + fpcol, + blkmem, + set, + stat, + var, + len, + rows, + vals, + removable, + ) end function SCIPcolExactFree(col, blkmem) - ccall((:SCIPcolExactFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_COLEXACT}}, Ptr{BMS_BLKMEM}), col, blkmem) + ccall( + (:SCIPcolExactFree, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_COLEXACT}}, Ptr{BMS_BLKMEM}), + col, + blkmem, + ) end function SCIPcolExactPrint(col, messagehdlr, file) - ccall((:SCIPcolExactPrint, libscip), Cvoid, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), col, messagehdlr, file) + ccall( + (:SCIPcolExactPrint, libscip), + Cvoid, + (Ptr{SCIP_COLEXACT}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), + col, + messagehdlr, + file, + ) end function SCIPcolExactAddCoef(col, blkmem, set, eventqueue, lpexact, row, val) - ccall((:SCIPcolExactAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), col, blkmem, set, eventqueue, lpexact, row, val) + ccall( + (:SCIPcolExactAddCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COLEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_RATIONAL}, + ), + col, + blkmem, + set, + eventqueue, + lpexact, + row, + val, + ) end function SCIPcolExactDelCoef(col, set, lpexact, row) - ccall((:SCIPcolExactDelCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROWEXACT}), col, set, lpexact, row) + ccall( + (:SCIPcolExactDelCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COLEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_ROWEXACT}, + ), + col, + set, + lpexact, + row, + ) end function SCIPcolExactChgCoef(col, blkmem, set, eventqueue, lpexact, row, val) - ccall((:SCIPcolExactChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), col, blkmem, set, eventqueue, lpexact, row, val) + ccall( + (:SCIPcolExactChgCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COLEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_RATIONAL}, + ), + col, + blkmem, + set, + eventqueue, + lpexact, + row, + val, + ) end function SCIPcolExactIncCoef(col, blkmem, set, eventqueue, lpexact, row, incval) - ccall((:SCIPcolExactIncCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), col, blkmem, set, eventqueue, lpexact, row, incval) + ccall( + (:SCIPcolExactIncCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COLEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_RATIONAL}, + ), + col, + blkmem, + set, + eventqueue, + lpexact, + row, + incval, + ) end function SCIPcolExactChgObj(col, set, lpexact, newobj) - ccall((:SCIPcolExactChgObj, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), col, set, lpexact, newobj) + ccall( + (:SCIPcolExactChgObj, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COLEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_RATIONAL}, + ), + col, + set, + lpexact, + newobj, + ) end function SCIPcolExactChgLb(col, set, lpexact, newlb) - ccall((:SCIPcolExactChgLb, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), col, set, lpexact, newlb) + ccall( + (:SCIPcolExactChgLb, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COLEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_RATIONAL}, + ), + col, + set, + lpexact, + newlb, + ) end function SCIPcolExactChgUb(col, set, lpexact, newub) - ccall((:SCIPcolExactChgUb, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), col, set, lpexact, newub) + ccall( + (:SCIPcolExactChgUb, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COLEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_RATIONAL}, + ), + col, + set, + lpexact, + newub, + ) end function SCIProwExactCapture(row) @@ -12162,7 +34191,14 @@ function SCIProwExactCapture(row) end function SCIProwExactPrint(row, messagehdlr, file) - ccall((:SCIProwExactPrint, libscip), Cvoid, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), row, messagehdlr, file) + ccall( + (:SCIProwExactPrint, libscip), + Cvoid, + (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), + row, + messagehdlr, + file, + ) end function SCIProwExactGetIndex(row) @@ -12170,375 +34206,1485 @@ function SCIProwExactGetIndex(row) end function SCIProwExactIsModifiable(row) - ccall((:SCIProwExactIsModifiable, libscip), Cuint, (Ptr{SCIP_ROWEXACT},), row) + ccall( + (:SCIProwExactIsModifiable, libscip), + Cuint, + (Ptr{SCIP_ROWEXACT},), + row, + ) end function SCIProwHasExRow(lpexact, row) - ccall((:SCIProwHasExRow, libscip), Cuint, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROW}), lpexact, row) + ccall( + (:SCIProwHasExRow, libscip), + Cuint, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_ROW}), + lpexact, + row, + ) end function SCIProwExactChgLhs(rowexact, set, lpexact, lhs) - ccall((:SCIProwExactChgLhs, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), rowexact, set, lpexact, lhs) + ccall( + (:SCIProwExactChgLhs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_RATIONAL}, + ), + rowexact, + set, + lpexact, + lhs, + ) end function SCIProwExactChgRhs(rowexact, set, lpexact, rhs) - ccall((:SCIProwExactChgRhs, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), rowexact, set, lpexact, rhs) + ccall( + (:SCIProwExactChgRhs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_RATIONAL}, + ), + rowexact, + set, + lpexact, + rhs, + ) end function SCIPcolGetColExact(col) - ccall((:SCIPcolGetColExact, libscip), Ptr{SCIP_COLEXACT}, (Ptr{SCIP_COL},), col) + ccall( + (:SCIPcolGetColExact, libscip), + Ptr{SCIP_COLEXACT}, + (Ptr{SCIP_COL},), + col, + ) end function SCIPcolExactCalcFarkasRedcostCoef(col, set, result, dual, usefarkas) - ccall((:SCIPcolExactCalcFarkasRedcostCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_COLEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_RATIONAL}}, Cuint), col, set, result, dual, usefarkas) -end - -function SCIProwExactCreate(row, fprow, fprowrhs, blkmem, set, stat, lpexact, len, cols, vals, lhs, rhs, isfprelaxable) - ccall((:SCIProwExactCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}, Cint, Ptr{Ptr{SCIP_COLEXACT}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint), row, fprow, fprowrhs, blkmem, set, stat, lpexact, len, cols, vals, lhs, rhs, isfprelaxable) -end - -function SCIProwExactCreateFromRow(fprow, blkmem, set, stat, eventqueue, prob, lpexact) - ccall((:SCIProwExactCreateFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP_ROW}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_PROB}, Ptr{SCIP_LPEXACT}), fprow, blkmem, set, stat, eventqueue, prob, lpexact) -end - -function SCIProwExactGenerateFpRows(blkmem, set, stat, eventqueue, lpexact, prob, row, rowlhs, rowrhs, onerowrelax, hasfprelax) - ccall((:SCIProwExactGenerateFpRows, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_PROB}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Ptr{Cuint}, Ptr{Cuint}), blkmem, set, stat, eventqueue, lpexact, prob, row, rowlhs, rowrhs, onerowrelax, hasfprelax) + ccall( + (:SCIPcolExactCalcFarkasRedcostCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_COLEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_RATIONAL}, + Ptr{Ptr{SCIP_RATIONAL}}, + Cuint, + ), + col, + set, + result, + dual, + usefarkas, + ) +end + +function SCIProwExactCreate( + row, + fprow, + fprowrhs, + blkmem, + set, + stat, + lpexact, + len, + cols, + vals, + lhs, + rhs, + isfprelaxable, +) + ccall( + (:SCIProwExactCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_ROWEXACT}}, + Ptr{SCIP_ROW}, + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_LPEXACT}, + Cint, + Ptr{Ptr{SCIP_COLEXACT}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Cuint, + ), + row, + fprow, + fprowrhs, + blkmem, + set, + stat, + lpexact, + len, + cols, + vals, + lhs, + rhs, + isfprelaxable, + ) +end + +function SCIProwExactCreateFromRow( + fprow, + blkmem, + set, + stat, + eventqueue, + prob, + lpexact, +) + ccall( + (:SCIProwExactCreateFromRow, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROW}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LPEXACT}, + ), + fprow, + blkmem, + set, + stat, + eventqueue, + prob, + lpexact, + ) +end + +function SCIProwExactGenerateFpRows( + blkmem, + set, + stat, + eventqueue, + lpexact, + prob, + row, + rowlhs, + rowrhs, + onerowrelax, + hasfprelax, +) + ccall( + (:SCIProwExactGenerateFpRows, libscip), + SCIP_RETCODE, + ( + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_ROW}, + Ptr{SCIP_ROW}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + blkmem, + set, + stat, + eventqueue, + lpexact, + prob, + row, + rowlhs, + rowrhs, + onerowrelax, + hasfprelax, + ) end function SCIPlpExactFlush(lpexact, blkmem, set, eventqueue) - ccall((:SCIPlpExactFlush, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}), lpexact, blkmem, set, eventqueue) + ccall( + (:SCIPlpExactFlush, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + ), + lpexact, + blkmem, + set, + eventqueue, + ) end function SCIPlpExactLink(lpexact, blkmem, set, eventqueue) - ccall((:SCIPlpExactLink, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}), lpexact, blkmem, set, eventqueue) + ccall( + (:SCIPlpExactLink, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + ), + lpexact, + blkmem, + set, + eventqueue, + ) end function SCIPlpExactBoundShiftUseful(lpexact) - ccall((:SCIPlpExactBoundShiftUseful, libscip), Cuint, (Ptr{SCIP_LPEXACT},), lpexact) + ccall( + (:SCIPlpExactBoundShiftUseful, libscip), + Cuint, + (Ptr{SCIP_LPEXACT},), + lpexact, + ) end function SCIPlpExactProjectShiftPossible(lpexact) - ccall((:SCIPlpExactProjectShiftPossible, libscip), Cuint, (Ptr{SCIP_LPEXACT},), lpexact) + ccall( + (:SCIPlpExactProjectShiftPossible, libscip), + Cuint, + (Ptr{SCIP_LPEXACT},), + lpexact, + ) end function SCIPlpExactIsSynced(lpexact, set, msg) - ccall((:SCIPlpExactIsSynced, libscip), Cuint, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), lpexact, set, msg) + ccall( + (:SCIPlpExactIsSynced, libscip), + Cuint, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), + lpexact, + set, + msg, + ) end function SCIPlpExactCreate(lpexact, blkmem, fplp, set, messagehdlr, stat, name) - ccall((:SCIPlpExactCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LPEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{Cchar}), lpexact, blkmem, fplp, set, messagehdlr, stat, name) + ccall( + (:SCIPlpExactCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_LPEXACT}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_LP}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{Cchar}, + ), + lpexact, + blkmem, + fplp, + set, + messagehdlr, + stat, + name, + ) end function SCIPlpExactFree(lpexact, blkmem, set) - ccall((:SCIPlpExactFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LPEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), lpexact, blkmem, set) + ccall( + (:SCIPlpExactFree, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_LPEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), + lpexact, + blkmem, + set, + ) end function SCIPlpExactAddCol(lpexact, set, col) - ccall((:SCIPlpExactAddCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_COLEXACT}), lpexact, set, col) + ccall( + (:SCIPlpExactAddCol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_COLEXACT}), + lpexact, + set, + col, + ) end function SCIPlpExactAddRow(lpexact, set, rowexact) - ccall((:SCIPlpExactAddRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_ROWEXACT}), lpexact, set, rowexact) + ccall( + (:SCIPlpExactAddRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_ROWEXACT}), + lpexact, + set, + rowexact, + ) end function SCIProwExactGetSolFeasibility(row, set, stat, sol, result) - ccall((:SCIProwExactGetSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), row, set, stat, sol, result) -end - -function SCIProwExactGetSolActivityWithErrorbound(rowexact, set, stat, sol, activity, errorbound) - ccall((:SCIProwExactGetSolActivityWithErrorbound, libscip), Cuint, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cdouble}), rowexact, set, stat, sol, activity, errorbound) + ccall( + (:SCIProwExactGetSolFeasibility, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_SOL}, + Ptr{SCIP_RATIONAL}, + ), + row, + set, + stat, + sol, + result, + ) +end + +function SCIProwExactGetSolActivityWithErrorbound( + rowexact, + set, + stat, + sol, + activity, + errorbound, +) + ccall( + (:SCIProwExactGetSolActivityWithErrorbound, libscip), + Cuint, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_SOL}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + rowexact, + set, + stat, + sol, + activity, + errorbound, + ) end function SCIProwExactGetSolActivity(rowexact, set, stat, sol, useexact, result) - ccall((:SCIProwExactGetSolActivity, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_RATIONAL}), rowexact, set, stat, sol, useexact, result) + ccall( + (:SCIProwExactGetSolActivity, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_SOL}, + Cuint, + Ptr{SCIP_RATIONAL}, + ), + rowexact, + set, + stat, + sol, + useexact, + result, + ) end function SCIProwExactRelease(row, blkmem, set, lpexact) - ccall((:SCIProwExactRelease, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), row, blkmem, set, lpexact) + ccall( + (:SCIProwExactRelease, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_ROWEXACT}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + ), + row, + blkmem, + set, + lpexact, + ) end function SCIProwExactFree(row, blkmem, set, lpexact) - ccall((:SCIProwExactFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), row, blkmem, set, lpexact) + ccall( + (:SCIProwExactFree, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_ROWEXACT}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + ), + row, + blkmem, + set, + lpexact, + ) end function SCIProwExactEnsureSize(row, blkmem, set, num) - ccall((:SCIProwExactEnsureSize, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), row, blkmem, set, num) + ccall( + (:SCIProwExactEnsureSize, libscip), + SCIP_RETCODE, + (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), + row, + blkmem, + set, + num, + ) end function SCIProwExactAddConstant(row, set, stat, lpexact, addval) - ccall((:SCIProwExactAddConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), row, set, stat, lpexact, addval) -end - -function SCIProwExactAddCoef(rowexact, blkmem, set, eventqueue, lpexact, colexact, val) - ccall((:SCIProwExactAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_COLEXACT}, Ptr{SCIP_RATIONAL}), rowexact, blkmem, set, eventqueue, lpexact, colexact, val) + ccall( + (:SCIProwExactAddConstant, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_RATIONAL}, + ), + row, + set, + stat, + lpexact, + addval, + ) +end + +function SCIProwExactAddCoef( + rowexact, + blkmem, + set, + eventqueue, + lpexact, + colexact, + val, +) + ccall( + (:SCIProwExactAddCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_COLEXACT}, + Ptr{SCIP_RATIONAL}, + ), + rowexact, + blkmem, + set, + eventqueue, + lpexact, + colexact, + val, + ) end function SCIProwExactDelCoef(row, set, lpexact, col) - ccall((:SCIProwExactDelCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_COLEXACT}), row, set, lpexact, col) + ccall( + (:SCIProwExactDelCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_COLEXACT}, + ), + row, + set, + lpexact, + col, + ) end function SCIProwExactChgCoef(row, blkmem, set, eventqueue, lpexact, col, val) - ccall((:SCIProwExactChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_COLEXACT}, Ptr{SCIP_RATIONAL}), row, blkmem, set, eventqueue, lpexact, col, val) + ccall( + (:SCIProwExactChgCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_COLEXACT}, + Ptr{SCIP_RATIONAL}, + ), + row, + blkmem, + set, + eventqueue, + lpexact, + col, + val, + ) end function SCIProwExactIncCoef(row, blkmem, set, eventqueue, lpexact, col, incval) - ccall((:SCIProwExactIncCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_COLEXACT}, Ptr{SCIP_RATIONAL}), row, blkmem, set, eventqueue, lpexact, col, incval) + ccall( + (:SCIProwExactIncCoef, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_COLEXACT}, + Ptr{SCIP_RATIONAL}, + ), + row, + blkmem, + set, + eventqueue, + lpexact, + col, + incval, + ) end function SCIProwExactChgConstant(row, stat, lpexact, constant) - ccall((:SCIProwExactChgConstant, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), row, stat, lpexact, constant) + ccall( + (:SCIProwExactChgConstant, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_STAT}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_RATIONAL}, + ), + row, + stat, + lpexact, + constant, + ) end function SCIProwExactGetLPFeasibility(row, set, stat, lpexact, result) - ccall((:SCIProwExactGetLPFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_RATIONAL}), row, set, stat, lpexact, result) + ccall( + (:SCIProwExactGetLPFeasibility, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_RATIONAL}, + ), + row, + set, + stat, + lpexact, + result, + ) end function SCIProwExactGetPseudoFeasibility(row, set, stat, result) - ccall((:SCIProwExactGetPseudoFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_RATIONAL}), row, set, stat, result) + ccall( + (:SCIProwExactGetPseudoFeasibility, libscip), + SCIP_RETCODE, + (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_RATIONAL}), + row, + set, + stat, + result, + ) end function SCIProwExactGetLPActivity(row, stat, lpexact) - ccall((:SCIProwExactGetLPActivity, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}), row, stat, lpexact) + ccall( + (:SCIProwExactGetLPActivity, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}, Ptr{SCIP_LPEXACT}), + row, + stat, + lpexact, + ) end function SCIProwExactGetPseudoActivity(row, stat) - ccall((:SCIProwExactGetPseudoActivity, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), row, stat) + ccall( + (:SCIProwExactGetPseudoActivity, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), + row, + stat, + ) end function SCIProwExactDelaySort(rowexact) - ccall((:SCIProwExactDelaySort, libscip), Cvoid, (Ptr{SCIP_ROWEXACT},), rowexact) + ccall( + (:SCIProwExactDelaySort, libscip), + Cvoid, + (Ptr{SCIP_ROWEXACT},), + rowexact, + ) end function SCIProwExactForceSort(rowexact, set) - ccall((:SCIProwExactForceSort, libscip), Cvoid, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}), rowexact, set) + ccall( + (:SCIProwExactForceSort, libscip), + Cvoid, + (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SET}), + rowexact, + set, + ) end function SCIProwExactRecalcLPActivity(rowexact, stat) - ccall((:SCIProwExactRecalcLPActivity, libscip), Cvoid, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), rowexact, stat) + ccall( + (:SCIProwExactRecalcLPActivity, libscip), + Cvoid, + (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), + rowexact, + stat, + ) end function SCIProwExactRecalcPseudoActivity(rowexact, stat) - ccall((:SCIProwExactRecalcPseudoActivity, libscip), Cvoid, (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), rowexact, stat) + ccall( + (:SCIProwExactRecalcPseudoActivity, libscip), + Cvoid, + (Ptr{SCIP_ROWEXACT}, Ptr{SCIP_STAT}), + rowexact, + stat, + ) end function SCIPcolExactGetObj(col) - ccall((:SCIPcolExactGetObj, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) + ccall( + (:SCIPcolExactGetObj, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_COLEXACT},), + col, + ) end function SCIPcolExactGetLb(col) - ccall((:SCIPcolExactGetLb, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) + ccall( + (:SCIPcolExactGetLb, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_COLEXACT},), + col, + ) end function SCIPcolExactGetUb(col) - ccall((:SCIPcolExactGetUb, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) + ccall( + (:SCIPcolExactGetUb, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_COLEXACT},), + col, + ) end function SCIPcolExactGetBestBound(col) - ccall((:SCIPcolExactGetBestBound, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) + ccall( + (:SCIPcolExactGetBestBound, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_COLEXACT},), + col, + ) end function SCIPcolExactGetPrimsol(col) - ccall((:SCIPcolExactGetPrimsol, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_COLEXACT},), col) + ccall( + (:SCIPcolExactGetPrimsol, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_COLEXACT},), + col, + ) end function SCIPlpExactUpdateVarObj(set, lpexact, var, oldobj, newobj) - ccall((:SCIPlpExactUpdateVarObj, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), set, lpexact, var, oldobj, newobj) + ccall( + (:SCIPlpExactUpdateVarObj, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + ), + set, + lpexact, + var, + oldobj, + newobj, + ) end function SCIPlpExactUpdateVarLbGlobal(lpexact, set, var, oldlb, newlb) - ccall((:SCIPlpExactUpdateVarLbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), lpexact, set, var, oldlb, newlb) + ccall( + (:SCIPlpExactUpdateVarLbGlobal, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + ), + lpexact, + set, + var, + oldlb, + newlb, + ) end function SCIPlpExactUpdateVarLb(lpexact, set, var, oldlb, newlb) - ccall((:SCIPlpExactUpdateVarLb, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), lpexact, set, var, oldlb, newlb) + ccall( + (:SCIPlpExactUpdateVarLb, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + ), + lpexact, + set, + var, + oldlb, + newlb, + ) end function SCIPlpExactUpdateVarUbGlobal(lpexact, set, var, oldub, newub) - ccall((:SCIPlpExactUpdateVarUbGlobal, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), lpexact, set, var, oldub, newub) + ccall( + (:SCIPlpExactUpdateVarUbGlobal, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + ), + lpexact, + set, + var, + oldub, + newub, + ) end function SCIPlpExactUpdateVarUb(lpexact, set, var, oldub, newub) - ccall((:SCIPlpExactUpdateVarUb, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), lpexact, set, var, oldub, newub) + ccall( + (:SCIPlpExactUpdateVarUb, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + ), + lpexact, + set, + var, + oldub, + newub, + ) end function SCIPlpExactUpdateAddVar(lpexact, set, var) - ccall((:SCIPlpExactUpdateAddVar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lpexact, set, var) + ccall( + (:SCIPlpExactUpdateAddVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), + lpexact, + set, + var, + ) end function SCIPlpExactUpdateDelVar(lpexact, set, var) - ccall((:SCIPlpExactUpdateDelVar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lpexact, set, var) + ccall( + (:SCIPlpExactUpdateDelVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), + lpexact, + set, + var, + ) end function SCIPlpExactUpdateVarColumn(lpexact, set, var) - ccall((:SCIPlpExactUpdateVarColumn, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lpexact, set, var) + ccall( + (:SCIPlpExactUpdateVarColumn, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), + lpexact, + set, + var, + ) end function SCIPlpExactUpdateVarLoose(lpexact, set, var) - ccall((:SCIPlpExactUpdateVarLoose, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), lpexact, set, var) + ccall( + (:SCIPlpExactUpdateVarLoose, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_VAR}), + lpexact, + set, + var, + ) end function SCIPlpExactDecNLoosevars(lpexact) - ccall((:SCIPlpExactDecNLoosevars, libscip), Cvoid, (Ptr{SCIP_LPEXACT},), lpexact) + ccall( + (:SCIPlpExactDecNLoosevars, libscip), + Cvoid, + (Ptr{SCIP_LPEXACT},), + lpexact, + ) end function SCIPlpExactGetNRows(lpexact) ccall((:SCIPlpExactGetNRows, libscip), Cint, (Ptr{SCIP_LPEXACT},), lpexact) end -function SCIPlpExactGetSol(lpexact, set, stat, primalfeasible, dualfeasible, overwritefplp) - ccall((:SCIPlpExactGetSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}, Cuint), lpexact, set, stat, primalfeasible, dualfeasible, overwritefplp) -end - -function SCIPlpExactGetUnboundedSol(lpexact, set, stat, primalfeasible, rayfeasible) - ccall((:SCIPlpExactGetUnboundedSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Ptr{Cuint}), lpexact, set, stat, primalfeasible, rayfeasible) +function SCIPlpExactGetSol( + lpexact, + set, + stat, + primalfeasible, + dualfeasible, + overwritefplp, +) + ccall( + (:SCIPlpExactGetSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{Cuint}, + Ptr{Cuint}, + Cuint, + ), + lpexact, + set, + stat, + primalfeasible, + dualfeasible, + overwritefplp, + ) +end + +function SCIPlpExactGetUnboundedSol( + lpexact, + set, + stat, + primalfeasible, + rayfeasible, +) + ccall( + (:SCIPlpExactGetUnboundedSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + lpexact, + set, + stat, + primalfeasible, + rayfeasible, + ) end function SCIPlpExactGetPrimalRay(lpexact, set, ray) - ccall((:SCIPlpExactGetPrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{Ptr{SCIP_RATIONAL}}), lpexact, set, ray) + ccall( + (:SCIPlpExactGetPrimalRay, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{Ptr{SCIP_RATIONAL}}), + lpexact, + set, + ray, + ) end function SCIPlpExactGetDualfarkas(lpexact, set, stat, valid, overwritefplp) - ccall((:SCIPlpExactGetDualfarkas, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Cuint), lpexact, set, stat, valid, overwritefplp) + ccall( + (:SCIPlpExactGetDualfarkas, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Cuint}, Cuint), + lpexact, + set, + stat, + valid, + overwritefplp, + ) end function SCIPlpExactGetIterations(lpexact, iterations) - ccall((:SCIPlpExactGetIterations, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{Cint}), lpexact, iterations) + ccall( + (:SCIPlpExactGetIterations, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{Cint}), + lpexact, + iterations, + ) end function SCIPlpExactGetObjval(lpexact, set, res) - ccall((:SCIPlpExactGetObjval, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}), lpexact, set, res) + ccall( + (:SCIPlpExactGetObjval, libscip), + Cvoid, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}), + lpexact, + set, + res, + ) end function SCIPlpExactGetPseudoObjval(lpexact, set, res) - ccall((:SCIPlpExactGetPseudoObjval, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}), lpexact, set, res) + ccall( + (:SCIPlpExactGetPseudoObjval, libscip), + Cvoid, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Ptr{SCIP_RATIONAL}), + lpexact, + set, + res, + ) end function SCIPlpExactShrinkCols(lpexact, set, newncols) - ccall((:SCIPlpExactShrinkCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cint), lpexact, set, newncols) + ccall( + (:SCIPlpExactShrinkCols, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cint), + lpexact, + set, + newncols, + ) end function SCIPlpExactShrinkRows(lpexact, blkmem, set, newnrows) - ccall((:SCIPlpExactShrinkRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), lpexact, blkmem, set, newnrows) + ccall( + (:SCIPlpExactShrinkRows, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Cint), + lpexact, + blkmem, + set, + newnrows, + ) end function SCIPlpExactDelRowset(lpexact, blkmem, set, rowdstat) - ccall((:SCIPlpExactDelRowset, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{Cint}), lpexact, blkmem, set, rowdstat) + ccall( + (:SCIPlpExactDelRowset, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{Cint}), + lpexact, + blkmem, + set, + rowdstat, + ) end function SCIPlpExactReset(lpexact, blkmem, set, stat, eventqueue) - ccall((:SCIPlpExactReset, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}), lpexact, blkmem, set, stat, eventqueue) + ccall( + (:SCIPlpExactReset, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + ), + lpexact, + blkmem, + set, + stat, + eventqueue, + ) end function SCIPlpExactClear(lpexact, blkmem, set) - ccall((:SCIPlpExactClear, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), lpexact, blkmem, set) + ccall( + (:SCIPlpExactClear, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), + lpexact, + blkmem, + set, + ) end function SCIPlpExactForceExactSolve(lpexact, set) - ccall((:SCIPlpExactForceExactSolve, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}), lpexact, set) + ccall( + (:SCIPlpExactForceExactSolve, libscip), + Cvoid, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}), + lpexact, + set, + ) end function SCIPlpExactForceSafeBound(lpexact, set) - ccall((:SCIPlpExactForceSafeBound, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}), lpexact, set) + ccall( + (:SCIPlpExactForceSafeBound, libscip), + Cvoid, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}), + lpexact, + set, + ) end function SCIPlpExactAllowExactSolve(lpexact, set, allowexact) - ccall((:SCIPlpExactAllowExactSolve, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cuint), lpexact, set, allowexact) + ccall( + (:SCIPlpExactAllowExactSolve, libscip), + Cvoid, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cuint), + lpexact, + set, + allowexact, + ) end function SCIPlpExactGetSolstat(lpexact) - ccall((:SCIPlpExactGetSolstat, libscip), SCIP_LPSOLSTAT, (Ptr{SCIP_LPEXACT},), lpexact) + ccall( + (:SCIPlpExactGetSolstat, libscip), + SCIP_LPSOLSTAT, + (Ptr{SCIP_LPEXACT},), + lpexact, + ) end function SCIPlpExactSetCutoffbound(lpexact, set, cutoffbound) - ccall((:SCIPlpExactSetCutoffbound, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cdouble), lpexact, set, cutoffbound) -end - -function SCIPlpExactSolveAndEval(lpexact, lp, set, messagehdlr, blkmem, stat, eventqueue, prob, itlim, lperror, usefarkas) - ccall((:SCIPlpExactSolveAndEval, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{SCIP_LP}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_PROB}, Clonglong, Ptr{Cuint}, Cuint), lpexact, lp, set, messagehdlr, blkmem, stat, eventqueue, prob, itlim, lperror, usefarkas) + ccall( + (:SCIPlpExactSetCutoffbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{SCIP_SET}, Cdouble), + lpexact, + set, + cutoffbound, + ) +end + +function SCIPlpExactSolveAndEval( + lpexact, + lp, + set, + messagehdlr, + blkmem, + stat, + eventqueue, + prob, + itlim, + lperror, + usefarkas, +) + ccall( + (:SCIPlpExactSolveAndEval, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_LP}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_PROB}, + Clonglong, + Ptr{Cuint}, + Cuint, + ), + lpexact, + lp, + set, + messagehdlr, + blkmem, + stat, + eventqueue, + prob, + itlim, + lperror, + usefarkas, + ) end function SCIPlpExactGetState(lpexact, blkmem, lpistate) - ccall((:SCIPlpExactGetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lpexact, blkmem, lpistate) -end - -function SCIPlpExactSetState(lpexact, blkmem, set, eventqueue, lpistate, wasprimfeas, wasprimchecked, wasdualfeas, wasdualchecked) - ccall((:SCIPlpExactSetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LPISTATE}, Cuint, Cuint, Cuint, Cuint), lpexact, blkmem, set, eventqueue, lpistate, wasprimfeas, wasprimchecked, wasdualfeas, wasdualchecked) + ccall( + (:SCIPlpExactGetState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), + lpexact, + blkmem, + lpistate, + ) +end + +function SCIPlpExactSetState( + lpexact, + blkmem, + set, + eventqueue, + lpistate, + wasprimfeas, + wasprimchecked, + wasdualfeas, + wasdualchecked, +) + ccall( + (:SCIPlpExactSetState, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LPISTATE}, + Cuint, + Cuint, + Cuint, + Cuint, + ), + lpexact, + blkmem, + set, + eventqueue, + lpistate, + wasprimfeas, + wasprimchecked, + wasdualfeas, + wasdualchecked, + ) end function SCIPlpExactFreeState(lpexact, blkmem, lpistate) - ccall((:SCIPlpExactFreeState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lpexact, blkmem, lpistate) + ccall( + (:SCIPlpExactFreeState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), + lpexact, + blkmem, + lpistate, + ) end function SCIPlpExactStartDive(lpexact, blkmem, set, stat) - ccall((:SCIPlpExactStartDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), lpexact, blkmem, set, stat) + ccall( + (:SCIPlpExactStartDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + lpexact, + blkmem, + set, + stat, + ) end function SCIPlpExactEndDive(lpexact, blkmem, set, stat, eventqueue, vars, nvars) - ccall((:SCIPlpExactEndDive, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{Ptr{SCIP_VAR}}, Cint), lpexact, blkmem, set, stat, eventqueue, vars, nvars) + ccall( + (:SCIPlpExactEndDive, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPEXACT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + ), + lpexact, + blkmem, + set, + stat, + eventqueue, + vars, + nvars, + ) end function SCIPlpExactWrite(lpexact, fname) - ccall((:SCIPlpExactWrite, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{Cchar}), lpexact, fname) + ccall( + (:SCIPlpExactWrite, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{Cchar}), + lpexact, + fname, + ) end function SCIPlpExactOverwriteFpDualSol(lpexact, dualfarkas) - ccall((:SCIPlpExactOverwriteFpDualSol, libscip), Cvoid, (Ptr{SCIP_LPEXACT}, Cuint), lpexact, dualfarkas) + ccall( + (:SCIPlpExactOverwriteFpDualSol, libscip), + Cvoid, + (Ptr{SCIP_LPEXACT}, Cuint), + lpexact, + dualfarkas, + ) end function SCIPlpExactSyncLPs(lpexact, blkmem, set) - ccall((:SCIPlpExactSyncLPs, libscip), SCIP_RETCODE, (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), lpexact, blkmem, set) -end - -function SCIPcreateEmptyRowConsExact(scip, rowexact, fprow, fprowrhs, lhs, rhs, isfprelaxable) - ccall((:SCIPcreateEmptyRowConsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint), scip, rowexact, fprow, fprowrhs, lhs, rhs, isfprelaxable) -end - -function SCIPcreateRowExact(scip, row, fprow, len, cols, vals, lhs, rhs, isfprelaxable) - ccall((:SCIPcreateRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWEXACT}}, Ptr{SCIP_ROW}, Cint, Ptr{Ptr{SCIP_COLEXACT}}, Ptr{Ptr{SCIP_RATIONAL}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Cuint), scip, row, fprow, len, cols, vals, lhs, rhs, isfprelaxable) + ccall( + (:SCIPlpExactSyncLPs, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPEXACT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}), + lpexact, + blkmem, + set, + ) +end + +function SCIPcreateEmptyRowConsExact( + scip, + rowexact, + fprow, + fprowrhs, + lhs, + rhs, + isfprelaxable, +) + ccall( + (:SCIPcreateEmptyRowConsExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROWEXACT}}, + Ptr{SCIP_ROW}, + Ptr{SCIP_ROW}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Cuint, + ), + scip, + rowexact, + fprow, + fprowrhs, + lhs, + rhs, + isfprelaxable, + ) +end + +function SCIPcreateRowExact( + scip, + row, + fprow, + len, + cols, + vals, + lhs, + rhs, + isfprelaxable, +) + ccall( + (:SCIPcreateRowExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROWEXACT}}, + Ptr{SCIP_ROW}, + Cint, + Ptr{Ptr{SCIP_COLEXACT}}, + Ptr{Ptr{SCIP_RATIONAL}}, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Cuint, + ), + scip, + row, + fprow, + len, + cols, + vals, + lhs, + rhs, + isfprelaxable, + ) end function SCIPcreateRowExactFromRow(scip, fprow) - ccall((:SCIPcreateRowExactFromRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROW}), scip, fprow) -end - -function SCIPgenerateFpRowsFromRowExact(scip, row, rowlhs, rowrhs, onerowrelax, hasfprelax) - ccall((:SCIPgenerateFpRowsFromRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Ptr{Cuint}, Ptr{Cuint}), scip, row, rowlhs, rowrhs, onerowrelax, hasfprelax) + ccall( + (:SCIPcreateRowExactFromRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROW}), + scip, + fprow, + ) +end + +function SCIPgenerateFpRowsFromRowExact( + scip, + row, + rowlhs, + rowrhs, + onerowrelax, + hasfprelax, +) + ccall( + (:SCIPgenerateFpRowsFromRowExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_ROW}, + Ptr{SCIP_ROW}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + row, + rowlhs, + rowrhs, + onerowrelax, + hasfprelax, + ) end function SCIPcaptureRowExact(scip, row) - ccall((:SCIPcaptureRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}), scip, row) + ccall( + (:SCIPcaptureRowExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}), + scip, + row, + ) end function SCIPreleaseRowExact(scip, row) - ccall((:SCIPreleaseRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWEXACT}}), scip, row) + ccall( + (:SCIPreleaseRowExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWEXACT}}), + scip, + row, + ) end function SCIPchgRowExactLhs(scip, row, lhs) - ccall((:SCIPchgRowExactLhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), scip, row, lhs) + ccall( + (:SCIPchgRowExactLhs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), + scip, + row, + lhs, + ) end function SCIPchgRowExactRhs(scip, row, rhs) - ccall((:SCIPchgRowExactRhs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), scip, row, rhs) + ccall( + (:SCIPchgRowExactRhs, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_RATIONAL}), + scip, + row, + rhs, + ) end function SCIPaddVarsToRowExact(scip, row, nvars, vars, vals) - ccall((:SCIPaddVarsToRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_RATIONAL}}), scip, row, nvars, vars, vals) -end - -function SCIPgetRowSolActivityWithErrorboundExact(scip, row, sol, activity, errorbound) - ccall((:SCIPgetRowSolActivityWithErrorboundExact, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cdouble}), scip, row, sol, activity, errorbound) + ccall( + (:SCIPaddVarsToRowExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_ROWEXACT}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_RATIONAL}}, + ), + scip, + row, + nvars, + vars, + vals, + ) +end + +function SCIPgetRowSolActivityWithErrorboundExact( + scip, + row, + sol, + activity, + errorbound, +) + ccall( + (:SCIPgetRowSolActivityWithErrorboundExact, libscip), + Cuint, + ( + Ptr{SCIP}, + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SOL}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + scip, + row, + sol, + activity, + errorbound, + ) end function SCIPgetRowSolActivityExact(scip, row, sol, useexact, result) - ccall((:SCIPgetRowSolActivityExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SOL}, Cuint, Ptr{SCIP_RATIONAL}), scip, row, sol, useexact, result) + ccall( + (:SCIPgetRowSolActivityExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_ROWEXACT}, + Ptr{SCIP_SOL}, + Cuint, + Ptr{SCIP_RATIONAL}, + ), + scip, + row, + sol, + useexact, + result, + ) end function SCIPgetRowSolFeasibilityExact(scip, row, sol, result) - ccall((:SCIPgetRowSolFeasibilityExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), scip, row, sol, result) + ccall( + (:SCIPgetRowSolFeasibilityExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), + scip, + row, + sol, + result, + ) end function SCIPprintRowExact(scip, row, file) - ccall((:SCIPprintRowExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{Libc.FILE}), scip, row, file) + ccall( + (:SCIPprintRowExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWEXACT}, Ptr{Libc.FILE}), + scip, + row, + file, + ) end function SCIPlpExactIsSolved(scip) @@ -12550,19 +35696,47 @@ function SCIPgetLPExactSolstat(scip) end function SCIPgetLPExactObjval(scip, result) - ccall((:SCIPgetLPExactObjval, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), scip, result) + ccall( + (:SCIPgetLPExactObjval, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_RATIONAL}), + scip, + result, + ) end function SCIPchgVarLbExactDive(scip, var, newbound) - ccall((:SCIPchgVarLbExactDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) + ccall( + (:SCIPchgVarLbExactDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + newbound, + ) end function SCIPchgVarUbExactDive(scip, var, newbound) - ccall((:SCIPchgVarUbExactDive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), scip, var, newbound) + ccall( + (:SCIPchgVarUbExactDive, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + scip, + var, + newbound, + ) end function SCIPsolveExactDiveLP(scip, itlim, lperror, cutoff) - ccall((:SCIPsolveExactDiveLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), scip, itlim, lperror, cutoff) + ccall( + (:SCIPsolveExactDiveLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Cuint}, Ptr{Cuint}), + scip, + itlim, + lperror, + cutoff, + ) end function SCIPstartExactDive(scip) @@ -12582,199 +35756,804 @@ function SCIPendExactDive(scip) end function SCIPwriteLPexact(scip, filename) - ccall((:SCIPwriteLPexact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}), scip, filename) -end - -function SCIPsetCopyPlugins(sourceset, targetset, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copyiisfinders, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, allvalid) - ccall((:SCIPsetCopyPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_SET}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sourceset, targetset, copyreaders, copypricers, copyconshdlrs, copyconflicthdlrs, copypresolvers, copyrelaxators, copyseparators, copycutselectors, copypropagators, copyheuristics, copyeventhdlrs, copynodeselectors, copybranchrules, copyiisfinders, copydisplays, copydialogs, copytables, copyexprhdlrs, copynlpis, allvalid) + ccall( + (:SCIPwriteLPexact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + filename, + ) +end + +function SCIPsetCopyPlugins( + sourceset, + targetset, + copyreaders, + copypricers, + copyconshdlrs, + copyconflicthdlrs, + copypresolvers, + copyrelaxators, + copyseparators, + copycutselectors, + copypropagators, + copyheuristics, + copyeventhdlrs, + copynodeselectors, + copybranchrules, + copyiisfinders, + copydisplays, + copydialogs, + copytables, + copyexprhdlrs, + copynlpis, + allvalid, +) + ccall( + (:SCIPsetCopyPlugins, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_SET}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + sourceset, + targetset, + copyreaders, + copypricers, + copyconshdlrs, + copyconflicthdlrs, + copypresolvers, + copyrelaxators, + copyseparators, + copycutselectors, + copypropagators, + copyheuristics, + copyeventhdlrs, + copynodeselectors, + copybranchrules, + copyiisfinders, + copydisplays, + copydialogs, + copytables, + copyexprhdlrs, + copynlpis, + allvalid, + ) end function SCIPsetCopyParams(sourceset, targetset, messagehdlr) - ccall((:SCIPsetCopyParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), sourceset, targetset, messagehdlr) + ccall( + (:SCIPsetCopyParams, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), + sourceset, + targetset, + messagehdlr, + ) end function SCIPsetCreate(set, messagehdlr, blkmem, scip) - ccall((:SCIPsetCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SET}}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP}), set, messagehdlr, blkmem, scip) + ccall( + (:SCIPsetCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_SET}}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP}), + set, + messagehdlr, + blkmem, + scip, + ) end function SCIPsetFree(set, blkmem) - ccall((:SCIPsetFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SET}}, Ptr{BMS_BLKMEM}), set, blkmem) + ccall( + (:SCIPsetFree, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_SET}}, Ptr{BMS_BLKMEM}), + set, + blkmem, + ) end function SCIPsetGetStage(set) ccall((:SCIPsetGetStage, libscip), SCIP_STAGE, (Ptr{SCIP_SET},), set) end -function SCIPsetAddBoolParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) - ccall((:SCIPsetAddBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cuint}, Cuint, Cuint, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) -end - -function SCIPsetAddIntParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) - ccall((:SCIPsetAddIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cint}, Cuint, Cint, Cint, Cint, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) -end - -function SCIPsetAddLongintParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) - ccall((:SCIPsetAddLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Clonglong}, Cuint, Clonglong, Clonglong, Clonglong, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) -end - -function SCIPsetAddRealParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) - ccall((:SCIPsetAddRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cdouble}, Cuint, Cdouble, Cdouble, Cdouble, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue, paramchgd, paramdata) -end - -function SCIPsetAddCharParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) - ccall((:SCIPsetAddCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Cuint, Cchar, Ptr{Cchar}, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues, paramchgd, paramdata) -end - -function SCIPsetAddStringParam(set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) - ccall((:SCIPsetAddStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Cuint, Ptr{Cchar}, Ptr{Cvoid}, Ptr{SCIP_PARAMDATA}), set, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) +function SCIPsetAddBoolParam( + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + paramchgd, + paramdata, +) + ccall( + (:SCIPsetAddBoolParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cuint}, + Cuint, + Cuint, + Ptr{Cvoid}, + Ptr{SCIP_PARAMDATA}, + ), + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + paramchgd, + paramdata, + ) +end + +function SCIPsetAddIntParam( + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + minvalue, + maxvalue, + paramchgd, + paramdata, +) + ccall( + (:SCIPsetAddIntParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cint}, + Cuint, + Cint, + Cint, + Cint, + Ptr{Cvoid}, + Ptr{SCIP_PARAMDATA}, + ), + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + minvalue, + maxvalue, + paramchgd, + paramdata, + ) +end + +function SCIPsetAddLongintParam( + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + minvalue, + maxvalue, + paramchgd, + paramdata, +) + ccall( + (:SCIPsetAddLongintParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Clonglong}, + Cuint, + Clonglong, + Clonglong, + Clonglong, + Ptr{Cvoid}, + Ptr{SCIP_PARAMDATA}, + ), + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + minvalue, + maxvalue, + paramchgd, + paramdata, + ) +end + +function SCIPsetAddRealParam( + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + minvalue, + maxvalue, + paramchgd, + paramdata, +) + ccall( + (:SCIPsetAddRealParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cdouble}, + Cuint, + Cdouble, + Cdouble, + Cdouble, + Ptr{Cvoid}, + Ptr{SCIP_PARAMDATA}, + ), + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + minvalue, + maxvalue, + paramchgd, + paramdata, + ) +end + +function SCIPsetAddCharParam( + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + allowedvalues, + paramchgd, + paramdata, +) + ccall( + (:SCIPsetAddCharParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cchar}, + Cuint, + Cchar, + Ptr{Cchar}, + Ptr{Cvoid}, + Ptr{SCIP_PARAMDATA}, + ), + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + allowedvalues, + paramchgd, + paramdata, + ) +end + +function SCIPsetAddStringParam( + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + paramchgd, + paramdata, +) + ccall( + (:SCIPsetAddStringParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Ptr{Cchar}}, + Cuint, + Ptr{Cchar}, + Ptr{Cvoid}, + Ptr{SCIP_PARAMDATA}, + ), + set, + messagehdlr, + blkmem, + name, + desc, + valueptr, + isadvanced, + defaultvalue, + paramchgd, + paramdata, + ) end function SCIPsetIsParamFixed(set, name) - ccall((:SCIPsetIsParamFixed, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetIsParamFixed, libscip), + Cuint, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetGetParam(set, name) - ccall((:SCIPsetGetParam, libscip), Ptr{SCIP_PARAM}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetGetParam, libscip), + Ptr{SCIP_PARAM}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetGetBoolParam(set, name, value) - ccall((:SCIPsetGetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cuint}), set, name, value) + ccall( + (:SCIPsetGetBoolParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cuint}), + set, + name, + value, + ) end function SCIPsetGetIntParam(set, name, value) - ccall((:SCIPsetGetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cint}), set, name, value) + ccall( + (:SCIPsetGetIntParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cint}), + set, + name, + value, + ) end function SCIPsetGetLongintParam(set, name, value) - ccall((:SCIPsetGetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Clonglong}), set, name, value) + ccall( + (:SCIPsetGetLongintParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Clonglong}), + set, + name, + value, + ) end function SCIPsetGetRealParam(set, name, value) - ccall((:SCIPsetGetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cdouble}), set, name, value) + ccall( + (:SCIPsetGetRealParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cdouble}), + set, + name, + value, + ) end function SCIPsetGetCharParam(set, name, value) - ccall((:SCIPsetGetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cchar}), set, name, value) + ccall( + (:SCIPsetGetCharParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cchar}), + set, + name, + value, + ) end function SCIPsetGetStringParam(set, name, value) - ccall((:SCIPsetGetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), set, name, value) + ccall( + (:SCIPsetGetStringParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), + set, + name, + value, + ) end function SCIPsetChgParamFixed(set, name, fixed) - ccall((:SCIPsetChgParamFixed, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Cuint), set, name, fixed) + ccall( + (:SCIPsetChgParamFixed, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Cuint), + set, + name, + fixed, + ) end function SCIPsetChgBoolParam(set, messagehdlr, param, value) - ccall((:SCIPsetChgBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cuint), set, messagehdlr, param, value) + ccall( + (:SCIPsetChgBoolParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cuint), + set, + messagehdlr, + param, + value, + ) end function SCIPsetSetBoolParam(set, messagehdlr, name, value) - ccall((:SCIPsetSetBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cuint), set, messagehdlr, name, value) + ccall( + (:SCIPsetSetBoolParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cuint), + set, + messagehdlr, + name, + value, + ) end function SCIPsetSetDefaultBoolParam(set, name, defaultvalue) - ccall((:SCIPsetSetDefaultBoolParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Cuint), set, name, defaultvalue) + ccall( + (:SCIPsetSetDefaultBoolParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Cuint), + set, + name, + defaultvalue, + ) end function SCIPsetChgIntParam(set, messagehdlr, param, value) - ccall((:SCIPsetChgIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cint), set, messagehdlr, param, value) + ccall( + (:SCIPsetChgIntParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cint), + set, + messagehdlr, + param, + value, + ) end function SCIPsetSetIntParam(set, messagehdlr, name, value) - ccall((:SCIPsetSetIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cint), set, messagehdlr, name, value) + ccall( + (:SCIPsetSetIntParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cint), + set, + messagehdlr, + name, + value, + ) end function SCIPsetSetDefaultIntParam(set, name, defaultvalue) - ccall((:SCIPsetSetDefaultIntParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Cint), set, name, defaultvalue) + ccall( + (:SCIPsetSetDefaultIntParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Cint), + set, + name, + defaultvalue, + ) end function SCIPsetChgLongintParam(set, messagehdlr, param, value) - ccall((:SCIPsetChgLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Clonglong), set, messagehdlr, param, value) + ccall( + (:SCIPsetChgLongintParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Clonglong), + set, + messagehdlr, + param, + value, + ) end function SCIPsetSetLongintParam(set, messagehdlr, name, value) - ccall((:SCIPsetSetLongintParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Clonglong), set, messagehdlr, name, value) + ccall( + (:SCIPsetSetLongintParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Clonglong), + set, + messagehdlr, + name, + value, + ) end function SCIPsetChgRealParam(set, messagehdlr, param, value) - ccall((:SCIPsetChgRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cdouble), set, messagehdlr, param, value) + ccall( + (:SCIPsetChgRealParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cdouble), + set, + messagehdlr, + param, + value, + ) end function SCIPsetSetRealParam(set, messagehdlr, name, value) - ccall((:SCIPsetSetRealParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cdouble), set, messagehdlr, name, value) + ccall( + (:SCIPsetSetRealParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cdouble), + set, + messagehdlr, + name, + value, + ) end function SCIPsetChgCharParam(set, messagehdlr, param, value) - ccall((:SCIPsetChgCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cchar), set, messagehdlr, param, value) + ccall( + (:SCIPsetChgCharParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Cchar), + set, + messagehdlr, + param, + value, + ) end function SCIPsetSetCharParam(set, messagehdlr, name, value) - ccall((:SCIPsetSetCharParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cchar), set, messagehdlr, name, value) + ccall( + (:SCIPsetSetCharParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cchar), + set, + messagehdlr, + name, + value, + ) end function SCIPsetChgStringParam(set, messagehdlr, param, value) - ccall((:SCIPsetChgStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Ptr{Cchar}), set, messagehdlr, param, value) + ccall( + (:SCIPsetChgStringParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_PARAM}, Ptr{Cchar}), + set, + messagehdlr, + param, + value, + ) end function SCIPsetSetStringParam(set, messagehdlr, name, value) - ccall((:SCIPsetSetStringParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Ptr{Cchar}), set, messagehdlr, name, value) + ccall( + (:SCIPsetSetStringParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Ptr{Cchar}), + set, + messagehdlr, + name, + value, + ) end function SCIPsetSetParam(set, messagehdlr, name, value) - ccall((:SCIPsetSetParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Ptr{Cchar}), set, messagehdlr, name, value) + ccall( + (:SCIPsetSetParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Ptr{Cchar}), + set, + messagehdlr, + name, + value, + ) end function SCIPsetReadParams(set, messagehdlr, filename) - ccall((:SCIPsetReadParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}), set, messagehdlr, filename) + ccall( + (:SCIPsetReadParams, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}), + set, + messagehdlr, + filename, + ) end function SCIPsetWriteParams(set, messagehdlr, filename, comments, onlychanged) - ccall((:SCIPsetWriteParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cuint, Cuint), set, messagehdlr, filename, comments, onlychanged) + ccall( + (:SCIPsetWriteParams, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, Cuint, Cuint), + set, + messagehdlr, + filename, + comments, + onlychanged, + ) end function SCIPsetResetParam(set, messagehdlr, name) - ccall((:SCIPsetResetParam, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}), set, messagehdlr, name) + ccall( + (:SCIPsetResetParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}), + set, + messagehdlr, + name, + ) end function SCIPsetResetParams(set, messagehdlr) - ccall((:SCIPsetResetParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), set, messagehdlr) + ccall( + (:SCIPsetResetParams, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), + set, + messagehdlr, + ) end function SCIPsetCheckParamValuePtrUnique(set) - ccall((:SCIPsetCheckParamValuePtrUnique, libscip), SCIP_RETCODE, (Ptr{SCIP_SET},), set) + ccall( + (:SCIPsetCheckParamValuePtrUnique, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET},), + set, + ) end function SCIPsetSetEmphasis(set, messagehdlr, paramemphasis, quiet) - ccall((:SCIPsetSetEmphasis, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMEMPHASIS, Cuint), set, messagehdlr, paramemphasis, quiet) + ccall( + (:SCIPsetSetEmphasis, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMEMPHASIS, Cuint), + set, + messagehdlr, + paramemphasis, + quiet, + ) end function SCIPsetSetReoptimizationParams(set, messagehdlr) - ccall((:SCIPsetSetReoptimizationParams, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), set, messagehdlr) + ccall( + (:SCIPsetSetReoptimizationParams, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}), + set, + messagehdlr, + ) end function SCIPsetEnableOrDisablePluginClocks(set, enabled) - ccall((:SCIPsetEnableOrDisablePluginClocks, libscip), Cvoid, (Ptr{SCIP_SET}, Cuint), set, enabled) + ccall( + (:SCIPsetEnableOrDisablePluginClocks, libscip), + Cvoid, + (Ptr{SCIP_SET}, Cuint), + set, + enabled, + ) end function SCIPsetSetSubscipsOff(set, messagehdlr, quiet) - ccall((:SCIPsetSetSubscipsOff, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Cuint), set, messagehdlr, quiet) + ccall( + (:SCIPsetSetSubscipsOff, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Cuint), + set, + messagehdlr, + quiet, + ) end function SCIPsetSetHeuristics(set, messagehdlr, paramsetting, quiet) - ccall((:SCIPsetSetHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), set, messagehdlr, paramsetting, quiet) + ccall( + (:SCIPsetSetHeuristics, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), + set, + messagehdlr, + paramsetting, + quiet, + ) end function SCIPsetSetPresolving(set, messagehdlr, paramsetting, quiet) - ccall((:SCIPsetSetPresolving, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), set, messagehdlr, paramsetting, quiet) + ccall( + (:SCIPsetSetPresolving, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), + set, + messagehdlr, + paramsetting, + quiet, + ) end function SCIPsetSetSeparating(set, messagehdlr, paramsetting, quiet) - ccall((:SCIPsetSetSeparating, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), set, messagehdlr, paramsetting, quiet) + ccall( + (:SCIPsetSetSeparating, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, SCIP_PARAMSETTING, Cuint), + set, + messagehdlr, + paramsetting, + quiet, + ) end function SCIPsetGetParams(set) - ccall((:SCIPsetGetParams, libscip), Ptr{Ptr{SCIP_PARAM}}, (Ptr{SCIP_SET},), set) + ccall( + (:SCIPsetGetParams, libscip), + Ptr{Ptr{SCIP_PARAM}}, + (Ptr{SCIP_SET},), + set, + ) end function SCIPsetGetNParams(set) @@ -12782,19 +36561,43 @@ function SCIPsetGetNParams(set) end function SCIPsetIncludeReader(set, reader) - ccall((:SCIPsetIncludeReader, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_READER}), set, reader) + ccall( + (:SCIPsetIncludeReader, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_READER}), + set, + reader, + ) end function SCIPsetFindReader(set, name) - ccall((:SCIPsetFindReader, libscip), Ptr{SCIP_READER}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindReader, libscip), + Ptr{SCIP_READER}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetIncludePricer(set, pricer) - ccall((:SCIPsetIncludePricer, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_PRICER}), set, pricer) + ccall( + (:SCIPsetIncludePricer, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_PRICER}), + set, + pricer, + ) end function SCIPsetFindPricer(set, name) - ccall((:SCIPsetFindPricer, libscip), Ptr{SCIP_PRICER}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindPricer, libscip), + Ptr{SCIP_PRICER}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortPricers(set) @@ -12806,11 +36609,23 @@ function SCIPsetSortPricersName(set) end function SCIPsetIncludeBenders(set, benders) - ccall((:SCIPsetIncludeBenders, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_BENDERS}), set, benders) + ccall( + (:SCIPsetIncludeBenders, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_BENDERS}), + set, + benders, + ) end function SCIPsetFindBenders(set, name) - ccall((:SCIPsetFindBenders, libscip), Ptr{SCIP_BENDERS}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindBenders, libscip), + Ptr{SCIP_BENDERS}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortBenders(set) @@ -12822,23 +36637,54 @@ function SCIPsetSortBendersName(set) end function SCIPsetIncludeConshdlr(set, conshdlr) - ccall((:SCIPsetIncludeConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CONSHDLR}), set, conshdlr) + ccall( + (:SCIPsetIncludeConshdlr, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_CONSHDLR}), + set, + conshdlr, + ) end function SCIPsetReinsertConshdlrSepaPrio(set, conshdlr, oldpriority) - ccall((:SCIPsetReinsertConshdlrSepaPrio, libscip), Cvoid, (Ptr{SCIP_SET}, Ptr{SCIP_CONSHDLR}, Cint), set, conshdlr, oldpriority) + ccall( + (:SCIPsetReinsertConshdlrSepaPrio, libscip), + Cvoid, + (Ptr{SCIP_SET}, Ptr{SCIP_CONSHDLR}, Cint), + set, + conshdlr, + oldpriority, + ) end function SCIPsetFindConshdlr(set, name) - ccall((:SCIPsetFindConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindConshdlr, libscip), + Ptr{SCIP_CONSHDLR}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetIncludeConflicthdlr(set, conflicthdlr) - ccall((:SCIPsetIncludeConflicthdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CONFLICTHDLR}), set, conflicthdlr) + ccall( + (:SCIPsetIncludeConflicthdlr, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_CONFLICTHDLR}), + set, + conflicthdlr, + ) end function SCIPsetFindConflicthdlr(set, name) - ccall((:SCIPsetFindConflicthdlr, libscip), Ptr{SCIP_CONFLICTHDLR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindConflicthdlr, libscip), + Ptr{SCIP_CONFLICTHDLR}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortConflicthdlrs(set) @@ -12846,15 +36692,32 @@ function SCIPsetSortConflicthdlrs(set) end function SCIPsetSortConflicthdlrsName(set) - ccall((:SCIPsetSortConflicthdlrsName, libscip), Cvoid, (Ptr{SCIP_SET},), set) + ccall( + (:SCIPsetSortConflicthdlrsName, libscip), + Cvoid, + (Ptr{SCIP_SET},), + set, + ) end function SCIPsetIncludePresol(set, presol) - ccall((:SCIPsetIncludePresol, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_PRESOL}), set, presol) + ccall( + (:SCIPsetIncludePresol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_PRESOL}), + set, + presol, + ) end function SCIPsetFindPresol(set, name) - ccall((:SCIPsetFindPresol, libscip), Ptr{SCIP_PRESOL}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindPresol, libscip), + Ptr{SCIP_PRESOL}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortPresols(set) @@ -12866,11 +36729,23 @@ function SCIPsetSortPresolsName(set) end function SCIPsetIncludeRelax(set, relax) - ccall((:SCIPsetIncludeRelax, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_RELAX}), set, relax) + ccall( + (:SCIPsetIncludeRelax, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_RELAX}), + set, + relax, + ) end function SCIPsetFindRelax(set, name) - ccall((:SCIPsetFindRelax, libscip), Ptr{SCIP_RELAX}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindRelax, libscip), + Ptr{SCIP_RELAX}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortRelaxs(set) @@ -12882,11 +36757,23 @@ function SCIPsetSortRelaxsName(set) end function SCIPsetIncludeSepa(set, sepa) - ccall((:SCIPsetIncludeSepa, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_SEPA}), set, sepa) + ccall( + (:SCIPsetIncludeSepa, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_SEPA}), + set, + sepa, + ) end function SCIPsetFindSepa(set, name) - ccall((:SCIPsetFindSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindSepa, libscip), + Ptr{SCIP_SEPA}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortSepas(set) @@ -12898,11 +36785,23 @@ function SCIPsetSortSepasName(set) end function SCIPsetIncludeCutsel(set, cutsel) - ccall((:SCIPsetIncludeCutsel, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CUTSEL}), set, cutsel) + ccall( + (:SCIPsetIncludeCutsel, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_CUTSEL}), + set, + cutsel, + ) end function SCIPsetFindCutsel(set, name) - ccall((:SCIPsetFindCutsel, libscip), Ptr{SCIP_CUTSEL}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindCutsel, libscip), + Ptr{SCIP_CUTSEL}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortCutsels(set) @@ -12910,11 +36809,23 @@ function SCIPsetSortCutsels(set) end function SCIPsetIncludeProp(set, prop) - ccall((:SCIPsetIncludeProp, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_PROP}), set, prop) + ccall( + (:SCIPsetIncludeProp, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_PROP}), + set, + prop, + ) end function SCIPsetFindProp(set, name) - ccall((:SCIPsetFindProp, libscip), Ptr{SCIP_PROP}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindProp, libscip), + Ptr{SCIP_PROP}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortProps(set) @@ -12930,27 +36841,62 @@ function SCIPsetSortPropsName(set) end function SCIPsetIncludeConcsolverType(set, concsolvertype) - ccall((:SCIPsetIncludeConcsolverType, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CONCSOLVERTYPE}), set, concsolvertype) + ccall( + (:SCIPsetIncludeConcsolverType, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_CONCSOLVERTYPE}), + set, + concsolvertype, + ) end function SCIPsetFindConcsolverType(set, name) - ccall((:SCIPsetFindConcsolverType, libscip), Ptr{SCIP_CONCSOLVERTYPE}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindConcsolverType, libscip), + Ptr{SCIP_CONCSOLVERTYPE}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetIncludeConcsolver(set, concsolver) - ccall((:SCIPsetIncludeConcsolver, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_CONCSOLVER}), set, concsolver) + ccall( + (:SCIPsetIncludeConcsolver, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_CONCSOLVER}), + set, + concsolver, + ) end function SCIPsetFreeConcsolvers(set) - ccall((:SCIPsetFreeConcsolvers, libscip), SCIP_RETCODE, (Ptr{SCIP_SET},), set) + ccall( + (:SCIPsetFreeConcsolvers, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET},), + set, + ) end function SCIPsetIncludeHeur(set, heur) - ccall((:SCIPsetIncludeHeur, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_HEUR}), set, heur) + ccall( + (:SCIPsetIncludeHeur, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_HEUR}), + set, + heur, + ) end function SCIPsetFindHeur(set, name) - ccall((:SCIPsetFindHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindHeur, libscip), + Ptr{SCIP_HEUR}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortHeurs(set) @@ -12962,11 +36908,23 @@ function SCIPsetSortHeursName(set) end function SCIPsetIncludeCompr(set, compr) - ccall((:SCIPsetIncludeCompr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_COMPR}), set, compr) + ccall( + (:SCIPsetIncludeCompr, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_COMPR}), + set, + compr, + ) end function SCIPsetFindCompr(set, name) - ccall((:SCIPsetFindCompr, libscip), Ptr{SCIP_COMPR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindCompr, libscip), + Ptr{SCIP_COMPR}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortComprs(set) @@ -12978,31 +36936,73 @@ function SCIPsetSortComprsName(set) end function SCIPsetIncludeEventhdlr(set, eventhdlr) - ccall((:SCIPsetIncludeEventhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_EVENTHDLR}), set, eventhdlr) + ccall( + (:SCIPsetIncludeEventhdlr, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_EVENTHDLR}), + set, + eventhdlr, + ) end function SCIPsetFindEventhdlr(set, name) - ccall((:SCIPsetFindEventhdlr, libscip), Ptr{SCIP_EVENTHDLR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindEventhdlr, libscip), + Ptr{SCIP_EVENTHDLR}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetIncludeNodesel(set, nodesel) - ccall((:SCIPsetIncludeNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), set, nodesel) + ccall( + (:SCIPsetIncludeNodesel, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), + set, + nodesel, + ) end function SCIPsetFindNodesel(set, name) - ccall((:SCIPsetFindNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindNodesel, libscip), + Ptr{SCIP_NODESEL}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetGetNodesel(set, stat) - ccall((:SCIPsetGetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_SET}, Ptr{SCIP_STAT}), set, stat) + ccall( + (:SCIPsetGetNodesel, libscip), + Ptr{SCIP_NODESEL}, + (Ptr{SCIP_SET}, Ptr{SCIP_STAT}), + set, + stat, + ) end function SCIPsetIncludeBranchrule(set, branchrule) - ccall((:SCIPsetIncludeBranchrule, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_BRANCHRULE}), set, branchrule) + ccall( + (:SCIPsetIncludeBranchrule, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_BRANCHRULE}), + set, + branchrule, + ) end function SCIPsetFindBranchrule(set, name) - ccall((:SCIPsetFindBranchrule, libscip), Ptr{SCIP_BRANCHRULE}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindBranchrule, libscip), + Ptr{SCIP_BRANCHRULE}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortBranchrules(set) @@ -13014,11 +37014,23 @@ function SCIPsetSortBranchrulesName(set) end function SCIPsetIncludeIISfinder(set, iisfinder) - ccall((:SCIPsetIncludeIISfinder, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_IISFINDER}), set, iisfinder) + ccall( + (:SCIPsetIncludeIISfinder, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_IISFINDER}), + set, + iisfinder, + ) end function SCIPsetFindIISfinder(set, name) - ccall((:SCIPsetFindIISfinder, libscip), Ptr{SCIP_IISFINDER}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindIISfinder, libscip), + Ptr{SCIP_IISFINDER}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortIISfinders(set) @@ -13026,35 +37038,83 @@ function SCIPsetSortIISfinders(set) end function SCIPsetIncludeDisp(set, disp) - ccall((:SCIPsetIncludeDisp, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_DISP}), set, disp) + ccall( + (:SCIPsetIncludeDisp, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_DISP}), + set, + disp, + ) end function SCIPsetFindDisp(set, name) - ccall((:SCIPsetFindDisp, libscip), Ptr{SCIP_DISP}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindDisp, libscip), + Ptr{SCIP_DISP}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetIncludeTable(set, table) - ccall((:SCIPsetIncludeTable, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_TABLE}), set, table) + ccall( + (:SCIPsetIncludeTable, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_TABLE}), + set, + table, + ) end function SCIPsetFindTable(set, name) - ccall((:SCIPsetFindTable, libscip), Ptr{SCIP_TABLE}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindTable, libscip), + Ptr{SCIP_TABLE}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetIncludeDialog(set, dialog) - ccall((:SCIPsetIncludeDialog, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_DIALOG}), set, dialog) + ccall( + (:SCIPsetIncludeDialog, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_DIALOG}), + set, + dialog, + ) end function SCIPsetExistsDialog(set, dialog) - ccall((:SCIPsetExistsDialog, libscip), Cuint, (Ptr{SCIP_SET}, Ptr{SCIP_DIALOG}), set, dialog) + ccall( + (:SCIPsetExistsDialog, libscip), + Cuint, + (Ptr{SCIP_SET}, Ptr{SCIP_DIALOG}), + set, + dialog, + ) end function SCIPsetIncludeExprhdlr(set, exprhdlr) - ccall((:SCIPsetIncludeExprhdlr, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_EXPRHDLR}), set, exprhdlr) + ccall( + (:SCIPsetIncludeExprhdlr, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_EXPRHDLR}), + set, + exprhdlr, + ) end function SCIPsetFindExprhdlr(set, name) - ccall((:SCIPsetFindExprhdlr, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindExprhdlr, libscip), + Ptr{SCIP_EXPRHDLR}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortExprhdlrs(set) @@ -13062,11 +37122,23 @@ function SCIPsetSortExprhdlrs(set) end function SCIPsetIncludeNlpi(set, nlpi) - ccall((:SCIPsetIncludeNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}), set, nlpi) + ccall( + (:SCIPsetIncludeNlpi, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}), + set, + nlpi, + ) end function SCIPsetFindNlpi(set, name) - ccall((:SCIPsetFindNlpi, libscip), Ptr{SCIP_NLPI}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindNlpi, libscip), + Ptr{SCIP_NLPI}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetSortNlpis(set) @@ -13074,75 +37146,193 @@ function SCIPsetSortNlpis(set) end function SCIPsetSetPriorityNlpi(set, nlpi, priority) - ccall((:SCIPsetSetPriorityNlpi, libscip), Cvoid, (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Cint), set, nlpi, priority) + ccall( + (:SCIPsetSetPriorityNlpi, libscip), + Cvoid, + (Ptr{SCIP_SET}, Ptr{SCIP_NLPI}, Cint), + set, + nlpi, + priority, + ) end function SCIPsetIncludeExternalCode(set, name, description) - ccall((:SCIPsetIncludeExternalCode, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cchar}), set, name, description) + ccall( + (:SCIPsetIncludeExternalCode, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{Cchar}, Ptr{Cchar}), + set, + name, + description, + ) end function SCIPsetIncludeBanditvtable(set, banditvtable) - ccall((:SCIPsetIncludeBanditvtable, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_BANDITVTABLE}), set, banditvtable) + ccall( + (:SCIPsetIncludeBanditvtable, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_BANDITVTABLE}), + set, + banditvtable, + ) end function SCIPsetFindBanditvtable(set, name) - ccall((:SCIPsetFindBanditvtable, libscip), Ptr{SCIP_BANDITVTABLE}, (Ptr{SCIP_SET}, Ptr{Cchar}), set, name) + ccall( + (:SCIPsetFindBanditvtable, libscip), + Ptr{SCIP_BANDITVTABLE}, + (Ptr{SCIP_SET}, Ptr{Cchar}), + set, + name, + ) end function SCIPsetInitPlugins(set, blkmem, stat) - ccall((:SCIPsetInitPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) + ccall( + (:SCIPsetInitPlugins, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), + set, + blkmem, + stat, + ) end function SCIPsetExitPlugins(set, blkmem, stat) - ccall((:SCIPsetExitPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) + ccall( + (:SCIPsetExitPlugins, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), + set, + blkmem, + stat, + ) end function SCIPsetInitprePlugins(set, blkmem, stat) - ccall((:SCIPsetInitprePlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) + ccall( + (:SCIPsetInitprePlugins, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), + set, + blkmem, + stat, + ) end function SCIPsetExitprePlugins(set, blkmem, stat) - ccall((:SCIPsetExitprePlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) + ccall( + (:SCIPsetExitprePlugins, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), + set, + blkmem, + stat, + ) end function SCIPsetInitsolPlugins(set, blkmem, stat) - ccall((:SCIPsetInitsolPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), set, blkmem, stat) + ccall( + (:SCIPsetInitsolPlugins, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}), + set, + blkmem, + stat, + ) end function SCIPsetExitsolPlugins(set, blkmem, stat, restart) - ccall((:SCIPsetExitsolPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Cuint), set, blkmem, stat, restart) + ccall( + (:SCIPsetExitsolPlugins, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Cuint), + set, + blkmem, + stat, + restart, + ) end function SCIPsetCalcMemGrowSize(set, num) - ccall((:SCIPsetCalcMemGrowSize, libscip), Cint, (Ptr{SCIP_SET}, Cint), set, num) + ccall( + (:SCIPsetCalcMemGrowSize, libscip), + Cint, + (Ptr{SCIP_SET}, Cint), + set, + num, + ) end function SCIPsetCalcTreeGrowSize(set, num) - ccall((:SCIPsetCalcTreeGrowSize, libscip), Cint, (Ptr{SCIP_SET}, Cint), set, num) + ccall( + (:SCIPsetCalcTreeGrowSize, libscip), + Cint, + (Ptr{SCIP_SET}, Cint), + set, + num, + ) end function SCIPsetCalcPathGrowSize(set, num) - ccall((:SCIPsetCalcPathGrowSize, libscip), Cint, (Ptr{SCIP_SET}, Cint), set, num) + ccall( + (:SCIPsetCalcPathGrowSize, libscip), + Cint, + (Ptr{SCIP_SET}, Cint), + set, + num, + ) end function SCIPsetSetVerbLevel(set, verblevel) - ccall((:SCIPsetSetVerbLevel, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, SCIP_VERBLEVEL), set, verblevel) + ccall( + (:SCIPsetSetVerbLevel, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, SCIP_VERBLEVEL), + set, + verblevel, + ) end function SCIPsetSetFeastol(set, lp, feastol) - ccall((:SCIPsetSetFeastol, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), set, lp, feastol) + ccall( + (:SCIPsetSetFeastol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Ptr{SCIP_LP}, Cdouble), + set, + lp, + feastol, + ) end function SCIPsetSetDualfeastol(set, dualfeastol) - ccall((:SCIPsetSetDualfeastol, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Cdouble), set, dualfeastol) + ccall( + (:SCIPsetSetDualfeastol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Cdouble), + set, + dualfeastol, + ) end function SCIPsetSetBarrierconvtol(set, barrierconvtol) - ccall((:SCIPsetSetBarrierconvtol, libscip), SCIP_RETCODE, (Ptr{SCIP_SET}, Cdouble), set, barrierconvtol) + ccall( + (:SCIPsetSetBarrierconvtol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SET}, Cdouble), + set, + barrierconvtol, + ) end function SCIPsetSetRelaxfeastol(set, relaxfeastol) - ccall((:SCIPsetSetRelaxfeastol, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, relaxfeastol) + ccall( + (:SCIPsetSetRelaxfeastol, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + relaxfeastol, + ) end function SCIPsetSetLimitChanged(set) @@ -13150,19 +37340,42 @@ function SCIPsetSetLimitChanged(set) end function SCIPsetGetPriceMaxvars(set, root) - ccall((:SCIPsetGetPriceMaxvars, libscip), Cint, (Ptr{SCIP_SET}, Cuint), set, root) + ccall( + (:SCIPsetGetPriceMaxvars, libscip), + Cint, + (Ptr{SCIP_SET}, Cuint), + set, + root, + ) end function SCIPsetGetSepaMaxcutsGenFactor(set, root) - ccall((:SCIPsetGetSepaMaxcutsGenFactor, libscip), Cdouble, (Ptr{SCIP_SET}, Cuint), set, root) + ccall( + (:SCIPsetGetSepaMaxcutsGenFactor, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cuint), + set, + root, + ) end function SCIPsetGetSepaMaxcuts(set, root) - ccall((:SCIPsetGetSepaMaxcuts, libscip), Cint, (Ptr{SCIP_SET}, Cuint), set, root) + ccall( + (:SCIPsetGetSepaMaxcuts, libscip), + Cint, + (Ptr{SCIP_SET}, Cuint), + set, + root, + ) end function SCIPsetGetSepaMaxCoefRatioRowprep(set) - ccall((:SCIPsetGetSepaMaxCoefRatioRowprep, libscip), Cdouble, (Ptr{SCIP_SET},), set) + ccall( + (:SCIPsetGetSepaMaxCoefRatioRowprep, libscip), + Cdouble, + (Ptr{SCIP_SET},), + set, + ) end function SCIPsetGetReferencevalue(set) @@ -13170,15 +37383,33 @@ function SCIPsetGetReferencevalue(set) end function SCIPsetGetDebugSolData(set) - ccall((:SCIPsetGetDebugSolData, libscip), Ptr{SCIP_DEBUGSOLDATA}, (Ptr{SCIP_SET},), set) + ccall( + (:SCIPsetGetDebugSolData, libscip), + Ptr{SCIP_DEBUGSOLDATA}, + (Ptr{SCIP_SET},), + set, + ) end function SCIPsetIsUpdateUnreliable(set, newvalue, oldvalue) - ccall((:SCIPsetIsUpdateUnreliable, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, newvalue, oldvalue) + ccall( + (:SCIPsetIsUpdateUnreliable, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + newvalue, + oldvalue, + ) end function SCIPsetInitializeRandomSeed(set, initialseedvalue) - ccall((:SCIPsetInitializeRandomSeed, libscip), Cuint, (Ptr{SCIP_SET}, Cuint), set, initialseedvalue) + ccall( + (:SCIPsetInitializeRandomSeed, libscip), + Cuint, + (Ptr{SCIP_SET}, Cuint), + set, + initialseedvalue, + ) end function SCIPsetInfinity(set) @@ -13234,31 +37465,78 @@ function SCIPsetRecompfac(set) end function SCIPsetIsEQ(set, val1, val2) - ccall((:SCIPsetIsEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsEQ, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsLT(set, val1, val2) - ccall((:SCIPsetIsLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsLT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsLE(set, val1, val2) - ccall((:SCIPsetIsLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsLE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsGT(set, val1, val2) - ccall((:SCIPsetIsGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsGT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsGE(set, val1, val2) - ccall((:SCIPsetIsGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsGE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsInfinity(set, val) - ccall((:SCIPsetIsInfinity, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsInfinity, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsHugeValue(set, val) - ccall((:SCIPsetIsHugeValue, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsHugeValue, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsZero(set, val) @@ -13266,23 +37544,54 @@ function SCIPsetIsZero(set, val) end function SCIPsetIsPositive(set, val) - ccall((:SCIPsetIsPositive, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsPositive, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsNegative(set, val) - ccall((:SCIPsetIsNegative, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsNegative, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsIntegral(set, val) - ccall((:SCIPsetIsIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsIntegral, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsScalingIntegral(set, val, scalar) - ccall((:SCIPsetIsScalingIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val, scalar) + ccall( + (:SCIPsetIsScalingIntegral, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val, + scalar, + ) end function SCIPsetIsFracIntegral(set, val) - ccall((:SCIPsetIsFracIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsFracIntegral, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetFloor(set, val) @@ -13302,215 +37611,563 @@ function SCIPsetFrac(set, val) end function SCIPsetIsSumEQ(set, val1, val2) - ccall((:SCIPsetIsSumEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumEQ, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumLT(set, val1, val2) - ccall((:SCIPsetIsSumLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumLT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumLE(set, val1, val2) - ccall((:SCIPsetIsSumLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumLE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumGT(set, val1, val2) - ccall((:SCIPsetIsSumGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumGT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumGE(set, val1, val2) - ccall((:SCIPsetIsSumGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumGE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumZero(set, val) - ccall((:SCIPsetIsSumZero, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsSumZero, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsSumPositive(set, val) - ccall((:SCIPsetIsSumPositive, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsSumPositive, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsSumNegative(set, val) - ccall((:SCIPsetIsSumNegative, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsSumNegative, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetSumFloor(set, val) - ccall((:SCIPsetSumFloor, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetSumFloor, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetSumCeil(set, val) - ccall((:SCIPsetSumCeil, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetSumCeil, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetSumRound(set, val) - ccall((:SCIPsetSumRound, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetSumRound, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetSumFrac(set, val) - ccall((:SCIPsetSumFrac, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetSumFrac, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsFeasEQ(set, val1, val2) - ccall((:SCIPsetIsFeasEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsFeasEQ, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsFeasLT(set, val1, val2) - ccall((:SCIPsetIsFeasLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsFeasLT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsFeasLE(set, val1, val2) - ccall((:SCIPsetIsFeasLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsFeasLE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsFeasGT(set, val1, val2) - ccall((:SCIPsetIsFeasGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsFeasGT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsFeasGE(set, val1, val2) - ccall((:SCIPsetIsFeasGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsFeasGE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsFeasZero(set, val) - ccall((:SCIPsetIsFeasZero, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsFeasZero, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsFeasPositive(set, val) - ccall((:SCIPsetIsFeasPositive, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsFeasPositive, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsFeasNegative(set, val) - ccall((:SCIPsetIsFeasNegative, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsFeasNegative, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsFeasIntegral(set, val) - ccall((:SCIPsetIsFeasIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsFeasIntegral, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsFeasFracIntegral(set, val) - ccall((:SCIPsetIsFeasFracIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsFeasFracIntegral, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetFeasFloor(set, val) - ccall((:SCIPsetFeasFloor, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetFeasFloor, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetFeasCeil(set, val) - ccall((:SCIPsetFeasCeil, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetFeasCeil, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetFeasRound(set, val) - ccall((:SCIPsetFeasRound, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetFeasRound, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetFeasFrac(set, val) - ccall((:SCIPsetFeasFrac, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetFeasFrac, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsDualfeasEQ(set, val1, val2) - ccall((:SCIPsetIsDualfeasEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsDualfeasEQ, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsDualfeasLT(set, val1, val2) - ccall((:SCIPsetIsDualfeasLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsDualfeasLT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsDualfeasLE(set, val1, val2) - ccall((:SCIPsetIsDualfeasLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsDualfeasLE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsDualfeasGT(set, val1, val2) - ccall((:SCIPsetIsDualfeasGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsDualfeasGT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsDualfeasGE(set, val1, val2) - ccall((:SCIPsetIsDualfeasGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsDualfeasGE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsDualfeasZero(set, val) - ccall((:SCIPsetIsDualfeasZero, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsDualfeasZero, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsDualfeasPositive(set, val) - ccall((:SCIPsetIsDualfeasPositive, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsDualfeasPositive, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsDualfeasNegative(set, val) - ccall((:SCIPsetIsDualfeasNegative, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsDualfeasNegative, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsDualfeasIntegral(set, val) - ccall((:SCIPsetIsDualfeasIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsDualfeasIntegral, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsDualfeasFracIntegral(set, val) - ccall((:SCIPsetIsDualfeasFracIntegral, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetIsDualfeasFracIntegral, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetDualfeasFloor(set, val) - ccall((:SCIPsetDualfeasFloor, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetDualfeasFloor, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetDualfeasCeil(set, val) - ccall((:SCIPsetDualfeasCeil, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetDualfeasCeil, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetDualfeasRound(set, val) - ccall((:SCIPsetDualfeasRound, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetDualfeasRound, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetDualfeasFrac(set, val) - ccall((:SCIPsetDualfeasFrac, libscip), Cdouble, (Ptr{SCIP_SET}, Cdouble), set, val) + ccall( + (:SCIPsetDualfeasFrac, libscip), + Cdouble, + (Ptr{SCIP_SET}, Cdouble), + set, + val, + ) end function SCIPsetIsLbBetter(set, newlb, oldlb, oldub) - ccall((:SCIPsetIsLbBetter, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble, Cdouble), set, newlb, oldlb, oldub) + ccall( + (:SCIPsetIsLbBetter, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble, Cdouble), + set, + newlb, + oldlb, + oldub, + ) end function SCIPsetIsUbBetter(set, newub, oldlb, oldub) - ccall((:SCIPsetIsUbBetter, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble, Cdouble), set, newub, oldlb, oldub) + ccall( + (:SCIPsetIsUbBetter, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble, Cdouble), + set, + newub, + oldlb, + oldub, + ) end function SCIPsetIsEfficacious(set, root, efficacy) - ccall((:SCIPsetIsEfficacious, libscip), Cuint, (Ptr{SCIP_SET}, Cuint, Cdouble), set, root, efficacy) + ccall( + (:SCIPsetIsEfficacious, libscip), + Cuint, + (Ptr{SCIP_SET}, Cuint, Cdouble), + set, + root, + efficacy, + ) end function SCIPsetIsRelEQ(set, val1, val2) - ccall((:SCIPsetIsRelEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsRelEQ, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsRelLT(set, val1, val2) - ccall((:SCIPsetIsRelLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsRelLT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsRelLE(set, val1, val2) - ccall((:SCIPsetIsRelLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsRelLE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsRelGT(set, val1, val2) - ccall((:SCIPsetIsRelGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsRelGT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsRelGE(set, val1, val2) - ccall((:SCIPsetIsRelGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsRelGE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumRelEQ(set, val1, val2) - ccall((:SCIPsetIsSumRelEQ, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumRelEQ, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumRelLT(set, val1, val2) - ccall((:SCIPsetIsSumRelLT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumRelLT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumRelLE(set, val1, val2) - ccall((:SCIPsetIsSumRelLE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumRelLE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumRelGT(set, val1, val2) - ccall((:SCIPsetIsSumRelGT, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumRelGT, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetIsSumRelGE(set, val1, val2) - ccall((:SCIPsetIsSumRelGE, libscip), Cuint, (Ptr{SCIP_SET}, Cdouble, Cdouble), set, val1, val2) + ccall( + (:SCIPsetIsSumRelGE, libscip), + Cuint, + (Ptr{SCIP_SET}, Cdouble, Cdouble), + set, + val1, + val2, + ) end function SCIPsetGetSubscipsOff(set) @@ -13518,219 +38175,1199 @@ function SCIPsetGetSubscipsOff(set) end function SCIPsolCreate(sol, blkmem, set, stat, primal, tree, heur) - ccall((:SCIPsolCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, heur) + ccall( + (:SCIPsolCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + tree, + heur, + ) end function SCIPsolCreateExact(sol, blkmem, set, stat, primal, tree, heur) - ccall((:SCIPsolCreateExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, heur) -end - -function SCIPsolCreateOriginal(sol, blkmem, set, stat, origprob, primal, tree, heur) - ccall((:SCIPsolCreateOriginal, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, origprob, primal, tree, heur) -end - -function SCIPsolCreateOriginalExact(sol, blkmem, set, stat, origprob, primal, tree, heur) - ccall((:SCIPsolCreateOriginalExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, origprob, primal, tree, heur) + ccall( + (:SCIPsolCreateExact, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + tree, + heur, + ) +end + +function SCIPsolCreateOriginal( + sol, + blkmem, + set, + stat, + origprob, + primal, + tree, + heur, +) + ccall( + (:SCIPsolCreateOriginal, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + origprob, + primal, + tree, + heur, + ) +end + +function SCIPsolCreateOriginalExact( + sol, + blkmem, + set, + stat, + origprob, + primal, + tree, + heur, +) + ccall( + (:SCIPsolCreateOriginalExact, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + origprob, + primal, + tree, + heur, + ) end function SCIPsolCopy(sol, blkmem, set, stat, primal, sourcesol) - ccall((:SCIPsolCopy, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_SOL}), sol, blkmem, set, stat, primal, sourcesol) + ccall( + (:SCIPsolCopy, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_SOL}, + ), + sol, + blkmem, + set, + stat, + primal, + sourcesol, + ) end function SCIPsolTransform(sol, transsol, blkmem, set, primal) - ccall((:SCIPsolTransform, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PRIMAL}), sol, transsol, blkmem, set, primal) + ccall( + (:SCIPsolTransform, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_PRIMAL}, + ), + sol, + transsol, + blkmem, + set, + primal, + ) end function SCIPsolAdjustImplicitSolVals(sol, set, stat, prob, tree, uselprows) - ccall((:SCIPsolAdjustImplicitSolVals, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Cuint), sol, set, stat, prob, tree, uselprows) -end - -function SCIPsolCreateLPSol(sol, blkmem, set, stat, prob, primal, tree, lp, heur) - ccall((:SCIPsolCreateLPSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, prob, primal, tree, lp, heur) + ccall( + (:SCIPsolAdjustImplicitSolVals, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Cuint, + ), + sol, + set, + stat, + prob, + tree, + uselprows, + ) +end + +function SCIPsolCreateLPSol( + sol, + blkmem, + set, + stat, + prob, + primal, + tree, + lp, + heur, +) + ccall( + (:SCIPsolCreateLPSol, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + prob, + primal, + tree, + lp, + heur, + ) end function SCIPsolCreateLPSolExact(sol, blkmem, set, stat, primal, tree, lp, heur) - ccall((:SCIPsolCreateLPSolExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, lp, heur) + ccall( + (:SCIPsolCreateLPSolExact, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + tree, + lp, + heur, + ) end function SCIPsolCreateNLPSol(sol, blkmem, set, stat, primal, tree, nlp, heur) - ccall((:SCIPsolCreateNLPSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_NLP}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, nlp, heur) -end - -function SCIPsolCreateRelaxSol(sol, blkmem, set, stat, primal, tree, relaxation, heur) - ccall((:SCIPsolCreateRelaxSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, relaxation, heur) -end - -function SCIPsolCreatePseudoSol(sol, blkmem, set, stat, prob, primal, tree, lp, heur) - ccall((:SCIPsolCreatePseudoSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, prob, primal, tree, lp, heur) -end - -function SCIPsolCreatePseudoSolExact(sol, blkmem, set, stat, primal, tree, lp, heur) - ccall((:SCIPsolCreatePseudoSolExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, lp, heur) -end - -function SCIPsolCreateCurrentSol(sol, blkmem, set, stat, prob, primal, tree, lp, heur) - ccall((:SCIPsolCreateCurrentSol, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, prob, primal, tree, lp, heur) -end - -function SCIPsolCreateCurrentSolExact(sol, blkmem, set, stat, primal, tree, lp, heur) - ccall((:SCIPsolCreateCurrentSolExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, lp, heur) + ccall( + (:SCIPsolCreateNLPSol, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_NLP}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + tree, + nlp, + heur, + ) +end + +function SCIPsolCreateRelaxSol( + sol, + blkmem, + set, + stat, + primal, + tree, + relaxation, + heur, +) + ccall( + (:SCIPsolCreateRelaxSol, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_RELAXATION}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + tree, + relaxation, + heur, + ) +end + +function SCIPsolCreatePseudoSol( + sol, + blkmem, + set, + stat, + prob, + primal, + tree, + lp, + heur, +) + ccall( + (:SCIPsolCreatePseudoSol, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + prob, + primal, + tree, + lp, + heur, + ) +end + +function SCIPsolCreatePseudoSolExact( + sol, + blkmem, + set, + stat, + primal, + tree, + lp, + heur, +) + ccall( + (:SCIPsolCreatePseudoSolExact, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + tree, + lp, + heur, + ) +end + +function SCIPsolCreateCurrentSol( + sol, + blkmem, + set, + stat, + prob, + primal, + tree, + lp, + heur, +) + ccall( + (:SCIPsolCreateCurrentSol, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + prob, + primal, + tree, + lp, + heur, + ) +end + +function SCIPsolCreateCurrentSolExact( + sol, + blkmem, + set, + stat, + primal, + tree, + lp, + heur, +) + ccall( + (:SCIPsolCreateCurrentSolExact, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + tree, + lp, + heur, + ) end function SCIPsolCreatePartial(sol, blkmem, set, stat, primal, heur) - ccall((:SCIPsolCreatePartial, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, heur) + ccall( + (:SCIPsolCreatePartial, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + heur, + ) end function SCIPsolCreateUnknown(sol, blkmem, set, stat, primal, tree, heur) - ccall((:SCIPsolCreateUnknown, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_HEUR}), sol, blkmem, set, stat, primal, tree, heur) + ccall( + (:SCIPsolCreateUnknown, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_SOL}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_HEUR}, + ), + sol, + blkmem, + set, + stat, + primal, + tree, + heur, + ) end function SCIPsolFree(sol, blkmem, primal) - ccall((:SCIPsolFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_PRIMAL}), sol, blkmem, primal) + ccall( + (:SCIPsolFree, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_SOL}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_PRIMAL}), + sol, + blkmem, + primal, + ) end function SCIPsolLinkLPSol(sol, set, stat, prob, tree, lp) - ccall((:SCIPsolLinkLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), sol, set, stat, prob, tree, lp) + ccall( + (:SCIPsolLinkLPSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + ), + sol, + set, + stat, + prob, + tree, + lp, + ) end function SCIPsolLinkLPSolExact(sol, set, lp) - ccall((:SCIPsolLinkLPSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), sol, set, lp) + ccall( + (:SCIPsolLinkLPSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), + sol, + set, + lp, + ) end function SCIPsolLinkNLPSol(sol, stat, tree, nlp) - ccall((:SCIPsolLinkNLPSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_NLP}), sol, stat, tree, nlp) + ccall( + (:SCIPsolLinkNLPSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_NLP}), + sol, + stat, + tree, + nlp, + ) end function SCIPsolLinkRelaxSol(sol, set, stat, tree, relaxation) - ccall((:SCIPsolLinkRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_RELAXATION}), sol, set, stat, tree, relaxation) + ccall( + (:SCIPsolLinkRelaxSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Ptr{SCIP_RELAXATION}, + ), + sol, + set, + stat, + tree, + relaxation, + ) end function SCIPsolLinkPseudoSol(sol, set, stat, prob, tree, lp) - ccall((:SCIPsolLinkPseudoSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), sol, set, stat, prob, tree, lp) + ccall( + (:SCIPsolLinkPseudoSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + ), + sol, + set, + stat, + prob, + tree, + lp, + ) end function SCIPsolLinkPseudoSolExact(sol, set, lp) - ccall((:SCIPsolLinkPseudoSolExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), sol, set, lp) + ccall( + (:SCIPsolLinkPseudoSolExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_LPEXACT}), + sol, + set, + lp, + ) end function SCIPsolLinkCurrentSol(sol, set, stat, prob, tree, lp) - ccall((:SCIPsolLinkCurrentSol, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), sol, set, stat, prob, tree, lp) + ccall( + (:SCIPsolLinkCurrentSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + ), + sol, + set, + stat, + prob, + tree, + lp, + ) end function SCIPsolClear(sol, stat, tree) - ccall((:SCIPsolClear, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), sol, stat, tree) + ccall( + (:SCIPsolClear, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), + sol, + stat, + tree, + ) end function SCIPsolSetUnknown(sol, stat, tree) - ccall((:SCIPsolSetUnknown, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), sol, stat, tree) + ccall( + (:SCIPsolSetUnknown, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SOL}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), + sol, + stat, + tree, + ) end function SCIPsolUnlink(sol, set, prob) - ccall((:SCIPsolUnlink, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), sol, set, prob) + ccall( + (:SCIPsolUnlink, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), + sol, + set, + prob, + ) end function SCIPsolUnlinkExact(sol, set, prob) - ccall((:SCIPsolUnlinkExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), sol, set, prob) + ccall( + (:SCIPsolUnlinkExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}), + sol, + set, + prob, + ) end function SCIPsolSetVal(sol, set, stat, tree, var, val) - ccall((:SCIPsolSetVal, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_VAR}, Cdouble), sol, set, stat, tree, var, val) + ccall( + (:SCIPsolSetVal, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Ptr{SCIP_VAR}, + Cdouble, + ), + sol, + set, + stat, + tree, + var, + val, + ) end function SCIPsolSetValExact(sol, set, stat, tree, var, val) - ccall((:SCIPsolSetValExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), sol, set, stat, tree, var, val) + ccall( + (:SCIPsolSetValExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + ), + sol, + set, + stat, + tree, + var, + val, + ) end function SCIPsolIncVal(sol, set, stat, tree, var, incval) - ccall((:SCIPsolIncVal, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_VAR}, Cdouble), sol, set, stat, tree, var, incval) + ccall( + (:SCIPsolIncVal, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Ptr{SCIP_VAR}, + Cdouble, + ), + sol, + set, + stat, + tree, + var, + incval, + ) end function SCIPsolGetVal(sol, set, stat, var) - ccall((:SCIPsolGetVal, libscip), Cdouble, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}), sol, set, stat, var) + ccall( + (:SCIPsolGetVal, libscip), + Cdouble, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}), + sol, + set, + stat, + var, + ) end function SCIPsolGetValExact(res, sol, set, stat, var) - ccall((:SCIPsolGetValExact, libscip), Cvoid, (Ptr{SCIP_RATIONAL}, Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}), res, sol, set, stat, var) + ccall( + (:SCIPsolGetValExact, libscip), + Cvoid, + ( + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_VAR}, + ), + res, + sol, + set, + stat, + var, + ) end function SCIPsolGetRayVal(sol, set, stat, var) - ccall((:SCIPsolGetRayVal, libscip), Cdouble, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}), sol, set, stat, var) + ccall( + (:SCIPsolGetRayVal, libscip), + Cdouble, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}), + sol, + set, + stat, + var, + ) end function SCIPsolGetObj(sol, set, transprob, origprob) - ccall((:SCIPsolGetObj, libscip), Cdouble, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}), sol, set, transprob, origprob) + ccall( + (:SCIPsolGetObj, libscip), + Cdouble, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}), + sol, + set, + transprob, + origprob, + ) end function SCIPsolGetObjExact(sol, set, transprob, origprob, objval) - ccall((:SCIPsolGetObjExact, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_RATIONAL}), sol, set, transprob, origprob, objval) + ccall( + (:SCIPsolGetObjExact, libscip), + Cvoid, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_RATIONAL}, + ), + sol, + set, + transprob, + origprob, + objval, + ) end function SCIPsolUpdateVarObj(sol, var, oldobj, newobj) - ccall((:SCIPsolUpdateVarObj, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble, Cdouble), sol, var, oldobj, newobj) + ccall( + (:SCIPsolUpdateVarObj, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Ptr{SCIP_VAR}, Cdouble, Cdouble), + sol, + var, + oldobj, + newobj, + ) end function SCIPsolMarkPartial(sol, set, stat, vars, nvars) - ccall((:SCIPsolMarkPartial, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{Ptr{SCIP_VAR}}, Cint), sol, set, stat, vars, nvars) -end - -function SCIPsolCheckOrig(sol, set, messagehdlr, blkmem, stat, prob, primal, printreason, completely, checkbounds, checkintegrality, checklprows, checkmodifiable, feasible) - ccall((:SCIPsolCheckOrig, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sol, set, messagehdlr, blkmem, stat, prob, primal, printreason, completely, checkbounds, checkintegrality, checklprows, checkmodifiable, feasible) -end - -function SCIPsolCheck(sol, set, messagehdlr, blkmem, stat, prob, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) - ccall((:SCIPsolCheck, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Cuint, Cuint, Cuint, Cuint, Cuint, Ptr{Cuint}), sol, set, messagehdlr, blkmem, stat, prob, printreason, completely, checkbounds, checkintegrality, checklprows, feasible) + ccall( + (:SCIPsolMarkPartial, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + ), + sol, + set, + stat, + vars, + nvars, + ) +end + +function SCIPsolCheckOrig( + sol, + set, + messagehdlr, + blkmem, + stat, + prob, + primal, + printreason, + completely, + checkbounds, + checkintegrality, + checklprows, + checkmodifiable, + feasible, +) + ccall( + (:SCIPsolCheckOrig, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + sol, + set, + messagehdlr, + blkmem, + stat, + prob, + primal, + printreason, + completely, + checkbounds, + checkintegrality, + checklprows, + checkmodifiable, + feasible, + ) +end + +function SCIPsolCheck( + sol, + set, + messagehdlr, + blkmem, + stat, + prob, + printreason, + completely, + checkbounds, + checkintegrality, + checklprows, + feasible, +) + ccall( + (:SCIPsolCheck, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Ptr{Cuint}, + ), + sol, + set, + messagehdlr, + blkmem, + stat, + prob, + printreason, + completely, + checkbounds, + checkintegrality, + checklprows, + feasible, + ) end function SCIPsolRound(sol, set, stat, prob, tree, success) - ccall((:SCIPsolRound, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{Cuint}), sol, set, stat, prob, tree, success) + ccall( + (:SCIPsolRound, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{Cuint}, + ), + sol, + set, + stat, + prob, + tree, + success, + ) end function SCIPsolMakeExact(sol, blkmem, set, stat, prob) - ccall((:SCIPsolMakeExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), sol, blkmem, set, stat, prob) + ccall( + (:SCIPsolMakeExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + ), + sol, + blkmem, + set, + stat, + prob, + ) end function SCIPsolMakeReal(sol, blkmem, set, stat, prob) - ccall((:SCIPsolMakeReal, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), sol, blkmem, set, stat, prob) + ccall( + (:SCIPsolMakeReal, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + ), + sol, + blkmem, + set, + stat, + prob, + ) end function SCIPsolUpdateVarsum(sol, set, stat, prob, weight) - ccall((:SCIPsolUpdateVarsum, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Cdouble), sol, set, stat, prob, weight) + ccall( + (:SCIPsolUpdateVarsum, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Cdouble), + sol, + set, + stat, + prob, + weight, + ) end function SCIPsolRetransform(sol, set, stat, origprob, transprob, hasinfval) - ccall((:SCIPsolRetransform, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Cuint}), sol, set, stat, origprob, transprob, hasinfval) + ccall( + (:SCIPsolRetransform, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{Cuint}, + ), + sol, + set, + stat, + origprob, + transprob, + hasinfval, + ) end function SCIPsolRetransformExact(sol, set, stat, origprob, transprob, hasinfval) - ccall((:SCIPsolRetransformExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Cuint}), sol, set, stat, origprob, transprob, hasinfval) + ccall( + (:SCIPsolRetransformExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{Cuint}, + ), + sol, + set, + stat, + origprob, + transprob, + hasinfval, + ) end function SCIPsolRecomputeObj(sol, set, stat, origprob) - ccall((:SCIPsolRecomputeObj, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), sol, set, stat, origprob) + ccall( + (:SCIPsolRecomputeObj, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), + sol, + set, + stat, + origprob, + ) end function SCIPsolRecomputeInternObjExact(sol, set, stat, prob) - ccall((:SCIPsolRecomputeInternObjExact, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), sol, set, stat, prob) + ccall( + (:SCIPsolRecomputeInternObjExact, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}), + sol, + set, + stat, + prob, + ) end function SCIPsolsAreEqual(sol1, sol2, set, stat, origprob, transprob) - ccall((:SCIPsolsAreEqual, libscip), Cuint, (Ptr{SCIP_SOL}, Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}), sol1, sol2, set, stat, origprob, transprob) -end - -function SCIPsolPrint(sol, set, messagehdlr, stat, prob, transprob, file, mipstart, printzeros) - ccall((:SCIPsolPrint, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Libc.FILE}, Cuint, Cuint), sol, set, messagehdlr, stat, prob, transprob, file, mipstart, printzeros) -end - -function SCIPsolPrintExact(sol, set, messagehdlr, stat, prob, transprob, file, mipstart, printzeros) - ccall((:SCIPsolPrintExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Libc.FILE}, Cuint, Cuint), sol, set, messagehdlr, stat, prob, transprob, file, mipstart, printzeros) -end - -function SCIPsolPrintRay(sol, set, messagehdlr, stat, prob, transprob, file, printzeros) - ccall((:SCIPsolPrintRay, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{Libc.FILE}, Cuint), sol, set, messagehdlr, stat, prob, transprob, file, printzeros) + ccall( + (:SCIPsolsAreEqual, libscip), + Cuint, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + ), + sol1, + sol2, + set, + stat, + origprob, + transprob, + ) +end + +function SCIPsolPrint( + sol, + set, + messagehdlr, + stat, + prob, + transprob, + file, + mipstart, + printzeros, +) + ccall( + (:SCIPsolPrint, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{Libc.FILE}, + Cuint, + Cuint, + ), + sol, + set, + messagehdlr, + stat, + prob, + transprob, + file, + mipstart, + printzeros, + ) +end + +function SCIPsolPrintExact( + sol, + set, + messagehdlr, + stat, + prob, + transprob, + file, + mipstart, + printzeros, +) + ccall( + (:SCIPsolPrintExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{Libc.FILE}, + Cuint, + Cuint, + ), + sol, + set, + messagehdlr, + stat, + prob, + transprob, + file, + mipstart, + printzeros, + ) +end + +function SCIPsolPrintRay( + sol, + set, + messagehdlr, + stat, + prob, + transprob, + file, + printzeros, +) + ccall( + (:SCIPsolPrintRay, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{Libc.FILE}, + Cuint, + ), + sol, + set, + messagehdlr, + stat, + prob, + transprob, + file, + printzeros, + ) end function SCIPsolSetOrigin(sol, origin) - ccall((:SCIPsolSetOrigin, libscip), Cvoid, (Ptr{SCIP_SOL}, SCIP_SOLORIGIN), sol, origin) + ccall( + (:SCIPsolSetOrigin, libscip), + Cvoid, + (Ptr{SCIP_SOL}, SCIP_SOLORIGIN), + sol, + origin, + ) end function SCIPsolResetViolations(sol) @@ -13738,39 +39375,115 @@ function SCIPsolResetViolations(sol) end function SCIPsolUpdateIntegralityViolation(sol, absviolintegrality) - ccall((:SCIPsolUpdateIntegralityViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble), sol, absviolintegrality) + ccall( + (:SCIPsolUpdateIntegralityViolation, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Cdouble), + sol, + absviolintegrality, + ) end function SCIPsolUpdateBoundViolation(sol, absviolbounds, relviolbounds) - ccall((:SCIPsolUpdateBoundViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble, Cdouble), sol, absviolbounds, relviolbounds) + ccall( + (:SCIPsolUpdateBoundViolation, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Cdouble, Cdouble), + sol, + absviolbounds, + relviolbounds, + ) end function SCIPsolUpdateLPRowViolation(sol, absviollprows, relviollprows) - ccall((:SCIPsolUpdateLPRowViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble, Cdouble), sol, absviollprows, relviollprows) + ccall( + (:SCIPsolUpdateLPRowViolation, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Cdouble, Cdouble), + sol, + absviollprows, + relviollprows, + ) end function SCIPsolUpdateConsViolation(sol, absviolcons, relviolcons) - ccall((:SCIPsolUpdateConsViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble, Cdouble), sol, absviolcons, relviolcons) + ccall( + (:SCIPsolUpdateConsViolation, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Cdouble, Cdouble), + sol, + absviolcons, + relviolcons, + ) end function SCIPsolUpdateLPConsViolation(sol, absviol, relviol) - ccall((:SCIPsolUpdateLPConsViolation, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble, Cdouble), sol, absviol, relviol) + ccall( + (:SCIPsolUpdateLPConsViolation, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Cdouble, Cdouble), + sol, + absviol, + relviol, + ) end function SCIPsolGetOrigObjExact(sol) - ccall((:SCIPsolGetOrigObjExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_SOL},), sol) -end - -function SCIPsolOverwriteFPSolWithExact(sol, set, stat, origprob, transprob, tree) - ccall((:SCIPsolOverwriteFPSolWithExact, libscip), SCIP_RETCODE, (Ptr{SCIP_SOL}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}), sol, set, stat, origprob, transprob, tree) + ccall( + (:SCIPsolGetOrigObjExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_SOL},), + sol, + ) +end + +function SCIPsolOverwriteFPSolWithExact( + sol, + set, + stat, + origprob, + transprob, + tree, +) + ccall( + (:SCIPsolOverwriteFPSolWithExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_SOL}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + ), + sol, + set, + stat, + origprob, + transprob, + tree, + ) end function SCIPvalsExactCopy(valsexact, blkmem, sourcevals) - ccall((:SCIPvalsExactCopy, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VALSEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_VALSEXACT}), valsexact, blkmem, sourcevals) + ccall( + (:SCIPvalsExactCopy, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_VALSEXACT}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_VALSEXACT}), + valsexact, + blkmem, + sourcevals, + ) end function SCIPsolOrigAddObjval(sol, addval) - ccall((:SCIPsolOrigAddObjval, libscip), Cvoid, (Ptr{SCIP_SOL}, Cdouble), sol, addval) + ccall( + (:SCIPsolOrigAddObjval, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Cdouble), + sol, + addval, + ) end function SCIPsolGetPrimalIndex(sol) @@ -13778,51 +39491,173 @@ function SCIPsolGetPrimalIndex(sol) end function SCIPsolSetPrimalIndex(sol, primalindex) - ccall((:SCIPsolSetPrimalIndex, libscip), Cvoid, (Ptr{SCIP_SOL}, Cint), sol, primalindex) + ccall( + (:SCIPsolSetPrimalIndex, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Cint), + sol, + primalindex, + ) end function SCIPnodepqCreate(nodepq, set, nodesel) - ccall((:SCIPnodepqCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODEPQ}}, Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), nodepq, set, nodesel) + ccall( + (:SCIPnodepqCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_NODEPQ}}, Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), + nodepq, + set, + nodesel, + ) end function SCIPnodepqDestroy(nodepq) - ccall((:SCIPnodepqDestroy, libscip), Cvoid, (Ptr{Ptr{SCIP_NODEPQ}},), nodepq) -end - -function SCIPnodepqFree(nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, lp) - ccall((:SCIPnodepqFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODEPQ}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, lp) -end - -function SCIPnodepqClear(nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, lp) - ccall((:SCIPnodepqClear, libscip), SCIP_RETCODE, (Ptr{SCIP_NODEPQ}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, lp) + ccall( + (:SCIPnodepqDestroy, libscip), + Cvoid, + (Ptr{Ptr{SCIP_NODEPQ}},), + nodepq, + ) +end + +function SCIPnodepqFree( + nodepq, + blkmem, + set, + stat, + eventqueue, + eventfilter, + tree, + lp, +) + ccall( + (:SCIPnodepqFree, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_NODEPQ}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + ), + nodepq, + blkmem, + set, + stat, + eventqueue, + eventfilter, + tree, + lp, + ) +end + +function SCIPnodepqClear( + nodepq, + blkmem, + set, + stat, + eventqueue, + eventfilter, + tree, + lp, +) + ccall( + (:SCIPnodepqClear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODEPQ}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + ), + nodepq, + blkmem, + set, + stat, + eventqueue, + eventfilter, + tree, + lp, + ) end function SCIPnodepqGetNodesel(nodepq) - ccall((:SCIPnodepqGetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_NODEPQ},), nodepq) + ccall( + (:SCIPnodepqGetNodesel, libscip), + Ptr{SCIP_NODESEL}, + (Ptr{SCIP_NODEPQ},), + nodepq, + ) end function SCIPnodepqSetNodesel(nodepq, set, nodesel) - ccall((:SCIPnodepqSetNodesel, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODEPQ}}, Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), nodepq, set, nodesel) + ccall( + (:SCIPnodepqSetNodesel, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_NODEPQ}}, Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), + nodepq, + set, + nodesel, + ) end function SCIPnodepqCompare(nodepq, set, node1, node2) - ccall((:SCIPnodepqCompare, libscip), Cint, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), nodepq, set, node1, node2) + ccall( + (:SCIPnodepqCompare, libscip), + Cint, + (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), + nodepq, + set, + node1, + node2, + ) end function SCIPnodepqInsert(nodepq, set, node) - ccall((:SCIPnodepqInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}), nodepq, set, node) + ccall( + (:SCIPnodepqInsert, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}), + nodepq, + set, + node, + ) end function SCIPnodepqRemove(nodepq, set, node) - ccall((:SCIPnodepqRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}), nodepq, set, node) + ccall( + (:SCIPnodepqRemove, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}), + nodepq, + set, + node, + ) end function SCIPnodepqFirst(nodepq) - ccall((:SCIPnodepqFirst, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_NODEPQ},), nodepq) + ccall( + (:SCIPnodepqFirst, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_NODEPQ},), + nodepq, + ) end function SCIPnodepqNodes(nodepq) - ccall((:SCIPnodepqNodes, libscip), Ptr{Ptr{SCIP_NODE}}, (Ptr{SCIP_NODEPQ},), nodepq) + ccall( + (:SCIPnodepqNodes, libscip), + Ptr{Ptr{SCIP_NODE}}, + (Ptr{SCIP_NODEPQ},), + nodepq, + ) end function SCIPnodepqLen(nodepq) @@ -13830,191 +39665,1167 @@ function SCIPnodepqLen(nodepq) end function SCIPnodepqGetLowerbound(nodepq, set) - ccall((:SCIPnodepqGetLowerbound, libscip), Cdouble, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), nodepq, set) + ccall( + (:SCIPnodepqGetLowerbound, libscip), + Cdouble, + (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), + nodepq, + set, + ) end function SCIPnodepqGetLowerboundExact(nodepq, set) - ccall((:SCIPnodepqGetLowerboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), nodepq, set) + ccall( + (:SCIPnodepqGetLowerboundExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), + nodepq, + set, + ) end function SCIPnodepqGetLowerboundNode(nodepq, set) - ccall((:SCIPnodepqGetLowerboundNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), nodepq, set) + ccall( + (:SCIPnodepqGetLowerboundNode, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_NODEPQ}, Ptr{SCIP_SET}), + nodepq, + set, + ) end function SCIPnodepqGetLowerboundSum(nodepq) - ccall((:SCIPnodepqGetLowerboundSum, libscip), Cdouble, (Ptr{SCIP_NODEPQ},), nodepq) -end - -function SCIPnodepqBound(nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, reopt, lp, cutoffbound) - ccall((:SCIPnodepqBound, libscip), SCIP_RETCODE, (Ptr{SCIP_NODEPQ}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Cdouble), nodepq, blkmem, set, stat, eventqueue, eventfilter, tree, reopt, lp, cutoffbound) + ccall( + (:SCIPnodepqGetLowerboundSum, libscip), + Cdouble, + (Ptr{SCIP_NODEPQ},), + nodepq, + ) +end + +function SCIPnodepqBound( + nodepq, + blkmem, + set, + stat, + eventqueue, + eventfilter, + tree, + reopt, + lp, + cutoffbound, +) + ccall( + (:SCIPnodepqBound, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODEPQ}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{SCIP_LP}, + Cdouble, + ), + nodepq, + blkmem, + set, + stat, + eventqueue, + eventfilter, + tree, + reopt, + lp, + cutoffbound, + ) end function SCIPnodeselCopyInclude(nodesel, set) - ccall((:SCIPnodeselCopyInclude, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) -end - -function SCIPnodeselCreate(nodesel, set, messagehdlr, blkmem, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) - ccall((:SCIPnodeselCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODESEL}}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{BMS_BLKMEM}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NODESELDATA}), nodesel, set, messagehdlr, blkmem, name, desc, stdpriority, memsavepriority, nodeselcopy, nodeselfree, nodeselinit, nodeselexit, nodeselinitsol, nodeselexitsol, nodeselselect, nodeselcomp, nodeseldata) + ccall( + (:SCIPnodeselCopyInclude, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), + nodesel, + set, + ) +end + +function SCIPnodeselCreate( + nodesel, + set, + messagehdlr, + blkmem, + name, + desc, + stdpriority, + memsavepriority, + nodeselcopy, + nodeselfree, + nodeselinit, + nodeselexit, + nodeselinitsol, + nodeselexitsol, + nodeselselect, + nodeselcomp, + nodeseldata, +) + ccall( + (:SCIPnodeselCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_NODESEL}}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{BMS_BLKMEM}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_NODESELDATA}, + ), + nodesel, + set, + messagehdlr, + blkmem, + name, + desc, + stdpriority, + memsavepriority, + nodeselcopy, + nodeselfree, + nodeselinit, + nodeselexit, + nodeselinitsol, + nodeselexitsol, + nodeselselect, + nodeselcomp, + nodeseldata, + ) end function SCIPnodeselFree(nodesel, set) - ccall((:SCIPnodeselFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODESEL}}, Ptr{SCIP_SET}), nodesel, set) + ccall( + (:SCIPnodeselFree, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_NODESEL}}, Ptr{SCIP_SET}), + nodesel, + set, + ) end function SCIPnodeselInit(nodesel, set) - ccall((:SCIPnodeselInit, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) + ccall( + (:SCIPnodeselInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), + nodesel, + set, + ) end function SCIPnodeselExit(nodesel, set) - ccall((:SCIPnodeselExit, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) + ccall( + (:SCIPnodeselExit, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), + nodesel, + set, + ) end function SCIPnodeselInitsol(nodesel, set) - ccall((:SCIPnodeselInitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) + ccall( + (:SCIPnodeselInitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), + nodesel, + set, + ) end function SCIPnodeselExitsol(nodesel, set) - ccall((:SCIPnodeselExitsol, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), nodesel, set) + ccall( + (:SCIPnodeselExitsol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}), + nodesel, + set, + ) end function SCIPnodeselSelect(nodesel, set, selnode) - ccall((:SCIPnodeselSelect, libscip), SCIP_RETCODE, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Ptr{Ptr{SCIP_NODE}}), nodesel, set, selnode) + ccall( + (:SCIPnodeselSelect, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Ptr{Ptr{SCIP_NODE}}), + nodesel, + set, + selnode, + ) end function SCIPnodeselCompare(nodesel, set, node1, node2) - ccall((:SCIPnodeselCompare, libscip), Cint, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), nodesel, set, node1, node2) + ccall( + (:SCIPnodeselCompare, libscip), + Cint, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), + nodesel, + set, + node1, + node2, + ) end function SCIPnodeselSetStdPriority(nodesel, set, priority) - ccall((:SCIPnodeselSetStdPriority, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Cint), nodesel, set, priority) + ccall( + (:SCIPnodeselSetStdPriority, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Cint), + nodesel, + set, + priority, + ) end function SCIPnodeselSetMemsavePriority(nodesel, set, priority) - ccall((:SCIPnodeselSetMemsavePriority, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Cint), nodesel, set, priority) + ccall( + (:SCIPnodeselSetMemsavePriority, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_SET}, Cint), + nodesel, + set, + priority, + ) end function SCIPnodeselSetCopy(nodesel, nodeselcopy) - ccall((:SCIPnodeselSetCopy, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselcopy) + ccall( + (:SCIPnodeselSetCopy, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + nodesel, + nodeselcopy, + ) end function SCIPnodeselSetFree(nodesel, nodeselfree) - ccall((:SCIPnodeselSetFree, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselfree) + ccall( + (:SCIPnodeselSetFree, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + nodesel, + nodeselfree, + ) end function SCIPnodeselSetInit(nodesel, nodeselinit) - ccall((:SCIPnodeselSetInit, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselinit) + ccall( + (:SCIPnodeselSetInit, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + nodesel, + nodeselinit, + ) end function SCIPnodeselSetExit(nodesel, nodeselexit) - ccall((:SCIPnodeselSetExit, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselexit) + ccall( + (:SCIPnodeselSetExit, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + nodesel, + nodeselexit, + ) end function SCIPnodeselSetInitsol(nodesel, nodeselinitsol) - ccall((:SCIPnodeselSetInitsol, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselinitsol) + ccall( + (:SCIPnodeselSetInitsol, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + nodesel, + nodeselinitsol, + ) end function SCIPnodeselSetExitsol(nodesel, nodeselexitsol) - ccall((:SCIPnodeselSetExitsol, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), nodesel, nodeselexitsol) + ccall( + (:SCIPnodeselSetExitsol, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{Cvoid}), + nodesel, + nodeselexitsol, + ) end function SCIPnodeselEnableOrDisableClocks(nodesel, enable) - ccall((:SCIPnodeselEnableOrDisableClocks, libscip), Cvoid, (Ptr{SCIP_NODESEL}, Cuint), nodesel, enable) -end - -function SCIPnodeCreateChild(node, blkmem, set, stat, tree, nodeselprio, estimate) - ccall((:SCIPnodeCreateChild, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Cdouble, Cdouble), node, blkmem, set, stat, tree, nodeselprio, estimate) -end - -function SCIPnodeFree(node, blkmem, set, stat, eventqueue, eventfilter, tree, lp) - ccall((:SCIPnodeFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_LP}), node, blkmem, set, stat, eventqueue, eventfilter, tree, lp) + ccall( + (:SCIPnodeselEnableOrDisableClocks, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Cuint), + nodesel, + enable, + ) +end + +function SCIPnodeCreateChild( + node, + blkmem, + set, + stat, + tree, + nodeselprio, + estimate, +) + ccall( + (:SCIPnodeCreateChild, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_NODE}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Cdouble, + Cdouble, + ), + node, + blkmem, + set, + stat, + tree, + nodeselprio, + estimate, + ) +end + +function SCIPnodeFree( + node, + blkmem, + set, + stat, + eventqueue, + eventfilter, + tree, + lp, +) + ccall( + (:SCIPnodeFree, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_NODE}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_TREE}, + Ptr{SCIP_LP}, + ), + node, + blkmem, + set, + stat, + eventqueue, + eventfilter, + tree, + lp, + ) end function SCIPnodeCaptureLPIState(node, nuses) - ccall((:SCIPnodeCaptureLPIState, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Cint), node, nuses) + ccall( + (:SCIPnodeCaptureLPIState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODE}, Cint), + node, + nuses, + ) end function SCIPnodeReleaseLPIState(node, blkmem, lp) - ccall((:SCIPnodeReleaseLPIState, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}), node, blkmem, lp) -end - -function SCIPnodeFocus(node, blkmem, set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable, cutoff, postponed, exitsolve) - ccall((:SCIPnodeFocus, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_NODE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_CONFLICT}, Ptr{SCIP_CONFLICTSTORE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{Cuint}, Cuint, Cuint), node, blkmem, set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable, cutoff, postponed, exitsolve) -end - -function SCIPnodeCutoff(node, set, stat, eventfilter, tree, transprob, origprob, reopt, lp, blkmem) - ccall((:SCIPnodeCutoff, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{BMS_BLKMEM}), node, set, stat, eventfilter, tree, transprob, origprob, reopt, lp, blkmem) + ccall( + (:SCIPnodeReleaseLPIState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}), + node, + blkmem, + lp, + ) +end + +function SCIPnodeFocus( + node, + blkmem, + set, + messagehdlr, + stat, + transprob, + origprob, + primal, + tree, + reopt, + lp, + branchcand, + conflict, + conflictstore, + eventqueue, + eventfilter, + cliquetable, + cutoff, + postponed, + exitsolve, +) + ccall( + (:SCIPnodeFocus, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_NODE}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_CONFLICT}, + Ptr{SCIP_CONFLICTSTORE}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + Ptr{Cuint}, + Cuint, + Cuint, + ), + node, + blkmem, + set, + messagehdlr, + stat, + transprob, + origprob, + primal, + tree, + reopt, + lp, + branchcand, + conflict, + conflictstore, + eventqueue, + eventfilter, + cliquetable, + cutoff, + postponed, + exitsolve, + ) +end + +function SCIPnodeCutoff( + node, + set, + stat, + eventfilter, + tree, + transprob, + origprob, + reopt, + lp, + blkmem, +) + ccall( + (:SCIPnodeCutoff, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_TREE}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_REOPT}, + Ptr{SCIP_LP}, + Ptr{BMS_BLKMEM}, + ), + node, + set, + stat, + eventfilter, + tree, + transprob, + origprob, + reopt, + lp, + blkmem, + ) end function SCIPnodePropagateAgain(node, set, stat, tree) - ccall((:SCIPnodePropagateAgain, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), node, set, stat, tree) + ccall( + (:SCIPnodePropagateAgain, libscip), + Cvoid, + (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}), + node, + set, + stat, + tree, + ) end function SCIPnodeMarkPropagated(node, tree) - ccall((:SCIPnodeMarkPropagated, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{SCIP_TREE}), node, tree) + ccall( + (:SCIPnodeMarkPropagated, libscip), + Cvoid, + (Ptr{SCIP_NODE}, Ptr{SCIP_TREE}), + node, + tree, + ) end function SCIPnodeAddCons(node, blkmem, set, stat, tree, cons) - ccall((:SCIPnodeAddCons, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_CONS}), node, blkmem, set, stat, tree, cons) + ccall( + (:SCIPnodeAddCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Ptr{SCIP_CONS}, + ), + node, + blkmem, + set, + stat, + tree, + cons, + ) end function SCIPnodeDelCons(node, blkmem, set, stat, tree, cons) - ccall((:SCIPnodeDelCons, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_CONS}), node, blkmem, set, stat, tree, cons) -end - -function SCIPnodeGetPropsBeforeDual(node, vars, varbounds, varboundtypes, npropvars, propvarssize) - ccall((:SCIPnodeGetPropsBeforeDual, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, vars, varbounds, varboundtypes, npropvars, propvarssize) -end - -function SCIPnodeGetPropsAfterDual(node, vars, varbounds, varboundtypes, nvars, varssize) - ccall((:SCIPnodeGetPropsAfterDual, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, vars, varbounds, varboundtypes, nvars, varssize) -end - -function SCIPnodeAddBoundinfer(node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, infercons, inferprop, inferinfo, probingchange) - ccall((:SCIPnodeAddBoundinfer, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{SCIP_VAR}, Cdouble, SCIP_BOUNDTYPE, Ptr{SCIP_CONS}, Ptr{SCIP_PROP}, Cint, Cuint), node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, infercons, inferprop, inferinfo, probingchange) -end - -function SCIPnodeAddBoundinferExact(node, blkmem, set, stat, transprob, origprob, tree, reopt, lpexact, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, infercons, inferprop, inferinfo, probingchange) - ccall((:SCIPnodeAddBoundinferExact, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, SCIP_BOUNDTYPE, Ptr{SCIP_CONS}, Ptr{SCIP_PROP}, Cint, Cuint), node, blkmem, set, stat, transprob, origprob, tree, reopt, lpexact, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, infercons, inferprop, inferinfo, probingchange) -end - -function SCIPnodeAddBoundchg(node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, probingchange) - ccall((:SCIPnodeAddBoundchg, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{SCIP_VAR}, Cdouble, SCIP_BOUNDTYPE, Cuint), node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, probingchange) -end - -function SCIPnodeAddBoundchgExact(node, blkmem, set, stat, transprob, origprob, tree, reopt, lpexact, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, probingchange) - ccall((:SCIPnodeAddBoundchgExact, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LPEXACT}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, SCIP_BOUNDTYPE, Cuint), node, blkmem, set, stat, transprob, origprob, tree, reopt, lpexact, branchcand, eventqueue, eventfilter, cliquetable, var, newbound, boundtype, probingchange) -end - -function SCIPnodeAddHoleinfer(node, blkmem, set, stat, tree, eventqueue, var, left, right, infercons, inferprop, inferinfo, probingchange, added) - ccall((:SCIPnodeAddHoleinfer, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{SCIP_CONS}, Ptr{SCIP_PROP}, Cint, Cuint, Ptr{Cuint}), node, blkmem, set, stat, tree, eventqueue, var, left, right, infercons, inferprop, inferinfo, probingchange, added) -end - -function SCIPnodeAddHolechg(node, blkmem, set, stat, tree, eventqueue, var, left, right, probingchange, added) - ccall((:SCIPnodeAddHolechg, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_TREE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cuint, Ptr{Cuint}), node, blkmem, set, stat, tree, eventqueue, var, left, right, probingchange, added) -end - -function SCIPnodeUpdateLowerbound(node, stat, set, eventfilter, tree, transprob, origprob, newbound, newboundexact) - ccall((:SCIPnodeUpdateLowerbound, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{SCIP_STAT}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Cdouble, Ptr{SCIP_RATIONAL}), node, stat, set, eventfilter, tree, transprob, origprob, newbound, newboundexact) -end - -function SCIPnodeUpdateLowerboundLP(node, set, stat, messagehdlr, eventfilter, tree, transprob, origprob, lp) - ccall((:SCIPnodeUpdateLowerboundLP, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_TREE}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}), node, set, stat, messagehdlr, eventfilter, tree, transprob, origprob, lp) + ccall( + (:SCIPnodeDelCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Ptr{SCIP_CONS}, + ), + node, + blkmem, + set, + stat, + tree, + cons, + ) +end + +function SCIPnodeGetPropsBeforeDual( + node, + vars, + varbounds, + varboundtypes, + npropvars, + propvarssize, +) + ccall( + (:SCIPnodeGetPropsBeforeDual, libscip), + Cvoid, + ( + Ptr{SCIP_NODE}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{SCIP_BOUNDTYPE}, + Ptr{Cint}, + Cint, + ), + node, + vars, + varbounds, + varboundtypes, + npropvars, + propvarssize, + ) +end + +function SCIPnodeGetPropsAfterDual( + node, + vars, + varbounds, + varboundtypes, + nvars, + varssize, +) + ccall( + (:SCIPnodeGetPropsAfterDual, libscip), + Cvoid, + ( + Ptr{SCIP_NODE}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{SCIP_BOUNDTYPE}, + Ptr{Cint}, + Cint, + ), + node, + vars, + varbounds, + varboundtypes, + nvars, + varssize, + ) +end + +function SCIPnodeAddBoundinfer( + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lp, + branchcand, + eventqueue, + eventfilter, + cliquetable, + var, + newbound, + boundtype, + infercons, + inferprop, + inferinfo, + probingchange, +) + ccall( + (:SCIPnodeAddBoundinfer, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + Ptr{SCIP_VAR}, + Cdouble, + SCIP_BOUNDTYPE, + Ptr{SCIP_CONS}, + Ptr{SCIP_PROP}, + Cint, + Cuint, + ), + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lp, + branchcand, + eventqueue, + eventfilter, + cliquetable, + var, + newbound, + boundtype, + infercons, + inferprop, + inferinfo, + probingchange, + ) +end + +function SCIPnodeAddBoundinferExact( + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lpexact, + branchcand, + eventqueue, + eventfilter, + cliquetable, + var, + newbound, + boundtype, + infercons, + inferprop, + inferinfo, + probingchange, +) + ccall( + (:SCIPnodeAddBoundinferExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + SCIP_BOUNDTYPE, + Ptr{SCIP_CONS}, + Ptr{SCIP_PROP}, + Cint, + Cuint, + ), + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lpexact, + branchcand, + eventqueue, + eventfilter, + cliquetable, + var, + newbound, + boundtype, + infercons, + inferprop, + inferinfo, + probingchange, + ) +end + +function SCIPnodeAddBoundchg( + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lp, + branchcand, + eventqueue, + eventfilter, + cliquetable, + var, + newbound, + boundtype, + probingchange, +) + ccall( + (:SCIPnodeAddBoundchg, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + Ptr{SCIP_VAR}, + Cdouble, + SCIP_BOUNDTYPE, + Cuint, + ), + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lp, + branchcand, + eventqueue, + eventfilter, + cliquetable, + var, + newbound, + boundtype, + probingchange, + ) +end + +function SCIPnodeAddBoundchgExact( + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lpexact, + branchcand, + eventqueue, + eventfilter, + cliquetable, + var, + newbound, + boundtype, + probingchange, +) + ccall( + (:SCIPnodeAddBoundchgExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{SCIP_LPEXACT}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + Ptr{SCIP_VAR}, + Ptr{SCIP_RATIONAL}, + SCIP_BOUNDTYPE, + Cuint, + ), + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lpexact, + branchcand, + eventqueue, + eventfilter, + cliquetable, + var, + newbound, + boundtype, + probingchange, + ) +end + +function SCIPnodeAddHoleinfer( + node, + blkmem, + set, + stat, + tree, + eventqueue, + var, + left, + right, + infercons, + inferprop, + inferinfo, + probingchange, + added, +) + ccall( + (:SCIPnodeAddHoleinfer, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Ptr{SCIP_CONS}, + Ptr{SCIP_PROP}, + Cint, + Cuint, + Ptr{Cuint}, + ), + node, + blkmem, + set, + stat, + tree, + eventqueue, + var, + left, + right, + infercons, + inferprop, + inferinfo, + probingchange, + added, + ) +end + +function SCIPnodeAddHolechg( + node, + blkmem, + set, + stat, + tree, + eventqueue, + var, + left, + right, + probingchange, + added, +) + ccall( + (:SCIPnodeAddHolechg, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_TREE}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Cuint, + Ptr{Cuint}, + ), + node, + blkmem, + set, + stat, + tree, + eventqueue, + var, + left, + right, + probingchange, + added, + ) +end + +function SCIPnodeUpdateLowerbound( + node, + stat, + set, + eventfilter, + tree, + transprob, + origprob, + newbound, + newboundexact, +) + ccall( + (:SCIPnodeUpdateLowerbound, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{SCIP_STAT}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_TREE}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Cdouble, + Ptr{SCIP_RATIONAL}, + ), + node, + stat, + set, + eventfilter, + tree, + transprob, + origprob, + newbound, + newboundexact, + ) +end + +function SCIPnodeUpdateLowerboundLP( + node, + set, + stat, + messagehdlr, + eventfilter, + tree, + transprob, + origprob, + lp, +) + ccall( + (:SCIPnodeUpdateLowerboundLP, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_TREE}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + ), + node, + set, + stat, + messagehdlr, + eventfilter, + tree, + transprob, + origprob, + lp, + ) end function SCIPchildChgNodeselPrio(tree, child, priority) - ccall((:SCIPchildChgNodeselPrio, libscip), Cvoid, (Ptr{SCIP_TREE}, Ptr{SCIP_NODE}, Cdouble), tree, child, priority) + ccall( + (:SCIPchildChgNodeselPrio, libscip), + Cvoid, + (Ptr{SCIP_TREE}, Ptr{SCIP_NODE}, Cdouble), + tree, + child, + priority, + ) end function SCIPnodeSetEstimate(node, set, newestimate) - ccall((:SCIPnodeSetEstimate, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Cdouble), node, set, newestimate) -end - -function SCIPnodePropagateImplics(node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, cutoff) - ccall((:SCIPnodePropagateImplics, libscip), SCIP_RETCODE, (Ptr{SCIP_NODE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Ptr{Cuint}), node, blkmem, set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable, cutoff) -end - -function SCIPnodeGetDualBoundchgs(node, vars, bounds, boundtypes, nvars, varssize) - ccall((:SCIPnodeGetDualBoundchgs, libscip), Cvoid, (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}, Ptr{Cint}, Cint), node, vars, bounds, boundtypes, nvars, varssize) + ccall( + (:SCIPnodeSetEstimate, libscip), + Cvoid, + (Ptr{SCIP_NODE}, Ptr{SCIP_SET}, Cdouble), + node, + set, + newestimate, + ) +end + +function SCIPnodePropagateImplics( + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lp, + branchcand, + eventqueue, + eventfilter, + cliquetable, + cutoff, +) + ccall( + (:SCIPnodePropagateImplics, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_NODE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + Ptr{Cuint}, + ), + node, + blkmem, + set, + stat, + transprob, + origprob, + tree, + reopt, + lp, + branchcand, + eventqueue, + eventfilter, + cliquetable, + cutoff, + ) +end + +function SCIPnodeGetDualBoundchgs( + node, + vars, + bounds, + boundtypes, + nvars, + varssize, +) + ccall( + (:SCIPnodeGetDualBoundchgs, libscip), + Cvoid, + ( + Ptr{SCIP_NODE}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{SCIP_BOUNDTYPE}, + Ptr{Cint}, + Cint, + ), + node, + vars, + bounds, + boundtypes, + nvars, + varssize, + ) end function SCIPnodeGetNDualBndchgs(node) @@ -14022,119 +40833,900 @@ function SCIPnodeGetNDualBndchgs(node) end function SCIPtreeCreate(tree, blkmem, set, nodesel) - ccall((:SCIPtreeCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_TREE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_NODESEL}), tree, blkmem, set, nodesel) + ccall( + (:SCIPtreeCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_TREE}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_NODESEL}, + ), + tree, + blkmem, + set, + nodesel, + ) end function SCIPtreeFree(tree, blkmem, set, stat, eventqueue, eventfilter, lp) - ccall((:SCIPtreeFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_TREE}}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}), tree, blkmem, set, stat, eventqueue, eventfilter, lp) + ccall( + (:SCIPtreeFree, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_TREE}}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_LP}, + ), + tree, + blkmem, + set, + stat, + eventqueue, + eventfilter, + lp, + ) end function SCIPtreeClear(tree, blkmem, set, stat, eventqueue, eventfilter, lp) - ccall((:SCIPtreeClear, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}), tree, blkmem, set, stat, eventqueue, eventfilter, lp) -end - -function SCIPtreeCreateRoot(tree, reopt, blkmem, set, stat, eventqueue, eventfilter, lp) - ccall((:SCIPtreeCreateRoot, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}), tree, reopt, blkmem, set, stat, eventqueue, eventfilter, lp) -end - -function SCIPtreeCreatePresolvingRoot(tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, primal, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable) - ccall((:SCIPtreeCreatePresolvingRoot, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_CONFLICT}, Ptr{SCIP_CONFLICTSTORE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}), tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, primal, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable) -end - -function SCIPtreeFreePresolvingRoot(tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, primal, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable) - ccall((:SCIPtreeFreePresolvingRoot, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_CONFLICT}, Ptr{SCIP_CONFLICTSTORE}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}), tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, primal, lp, branchcand, conflict, conflictstore, eventqueue, eventfilter, cliquetable) + ccall( + (:SCIPtreeClear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_LP}, + ), + tree, + blkmem, + set, + stat, + eventqueue, + eventfilter, + lp, + ) +end + +function SCIPtreeCreateRoot( + tree, + reopt, + blkmem, + set, + stat, + eventqueue, + eventfilter, + lp, +) + ccall( + (:SCIPtreeCreateRoot, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_LP}, + ), + tree, + reopt, + blkmem, + set, + stat, + eventqueue, + eventfilter, + lp, + ) +end + +function SCIPtreeCreatePresolvingRoot( + tree, + reopt, + blkmem, + set, + messagehdlr, + stat, + transprob, + origprob, + primal, + lp, + branchcand, + conflict, + conflictstore, + eventqueue, + eventfilter, + cliquetable, +) + ccall( + (:SCIPtreeCreatePresolvingRoot, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_CONFLICT}, + Ptr{SCIP_CONFLICTSTORE}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + ), + tree, + reopt, + blkmem, + set, + messagehdlr, + stat, + transprob, + origprob, + primal, + lp, + branchcand, + conflict, + conflictstore, + eventqueue, + eventfilter, + cliquetable, + ) +end + +function SCIPtreeFreePresolvingRoot( + tree, + reopt, + blkmem, + set, + messagehdlr, + stat, + transprob, + origprob, + primal, + lp, + branchcand, + conflict, + conflictstore, + eventqueue, + eventfilter, + cliquetable, +) + ccall( + (:SCIPtreeFreePresolvingRoot, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_CONFLICT}, + Ptr{SCIP_CONFLICTSTORE}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + ), + tree, + reopt, + blkmem, + set, + messagehdlr, + stat, + transprob, + origprob, + primal, + lp, + branchcand, + conflict, + conflictstore, + eventqueue, + eventfilter, + cliquetable, + ) end function SCIPtreeGetNodesel(tree) - ccall((:SCIPtreeGetNodesel, libscip), Ptr{SCIP_NODESEL}, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetNodesel, libscip), + Ptr{SCIP_NODESEL}, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeSetNodesel(tree, set, messagehdlr, stat, nodesel) - ccall((:SCIPtreeSetNodesel, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_NODESEL}), tree, set, messagehdlr, stat, nodesel) -end - -function SCIPtreeCutoff(tree, reopt, blkmem, set, stat, eventqueue, eventfilter, lp, cutoffbound) - ccall((:SCIPtreeCutoff, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}, Cdouble), tree, reopt, blkmem, set, stat, eventqueue, eventfilter, lp, cutoffbound) -end - -function SCIPtreeLoadLP(tree, blkmem, set, eventqueue, eventfilter, lp, initroot) - ccall((:SCIPtreeLoadLP, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_LP}, Ptr{Cuint}), tree, blkmem, set, eventqueue, eventfilter, lp, initroot) + ccall( + (:SCIPtreeSetNodesel, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_NODESEL}, + ), + tree, + set, + messagehdlr, + stat, + nodesel, + ) +end + +function SCIPtreeCutoff( + tree, + reopt, + blkmem, + set, + stat, + eventqueue, + eventfilter, + lp, + cutoffbound, +) + ccall( + (:SCIPtreeCutoff, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_LP}, + Cdouble, + ), + tree, + reopt, + blkmem, + set, + stat, + eventqueue, + eventfilter, + lp, + cutoffbound, + ) +end + +function SCIPtreeLoadLP( + tree, + blkmem, + set, + eventqueue, + eventfilter, + lp, + initroot, +) + ccall( + (:SCIPtreeLoadLP, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_LP}, + Ptr{Cuint}, + ), + tree, + blkmem, + set, + eventqueue, + eventfilter, + lp, + initroot, + ) end function SCIPtreeLoadLPState(tree, blkmem, set, prob, stat, eventqueue, lp) - ccall((:SCIPtreeLoadLPState, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_STAT}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), tree, blkmem, set, prob, stat, eventqueue, lp) -end - -function SCIPtreeCalcNodeselPriority(tree, set, stat, var, branchdir, targetvalue) - ccall((:SCIPtreeCalcNodeselPriority, libscip), Cdouble, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble), tree, set, stat, var, branchdir, targetvalue) + ccall( + (:SCIPtreeLoadLPState, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_PROB}, + Ptr{SCIP_STAT}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + ), + tree, + blkmem, + set, + prob, + stat, + eventqueue, + lp, + ) +end + +function SCIPtreeCalcNodeselPriority( + tree, + set, + stat, + var, + branchdir, + targetvalue, +) + ccall( + (:SCIPtreeCalcNodeselPriority, libscip), + Cdouble, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_VAR}, + SCIP_BRANCHDIR, + Cdouble, + ), + tree, + set, + stat, + var, + branchdir, + targetvalue, + ) end function SCIPtreeCalcChildEstimate(tree, set, stat, var, targetvalue) - ccall((:SCIPtreeCalcChildEstimate, libscip), Cdouble, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, Cdouble), tree, set, stat, var, targetvalue) -end - -function SCIPtreeBranchVar(tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, val, downchild, eqchild, upchild) - ccall((:SCIPtreeBranchVar, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_VAR}, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, val, downchild, eqchild, upchild) -end - -function SCIPtreeBranchVarExact(tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, downchild, upchild) - ccall((:SCIPtreeBranchVarExact, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, downchild, upchild) -end - -function SCIPtreeBranchVarHole(tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, left, right, downchild, upchild) - ccall((:SCIPtreeBranchVarHole, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Ptr{SCIP_NODE}}, Ptr{Ptr{SCIP_NODE}}), tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, left, right, downchild, upchild) -end - -function SCIPtreeBranchVarNary(tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, val, n, minwidth, widthfactor, nchildren) - ccall((:SCIPtreeBranchVarNary, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_VAR}, Cdouble, Cint, Cdouble, Cdouble, Ptr{Cint}), tree, reopt, blkmem, set, stat, transprob, origprob, lp, branchcand, eventqueue, eventfilter, var, val, n, minwidth, widthfactor, nchildren) + ccall( + (:SCIPtreeCalcChildEstimate, libscip), + Cdouble, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_VAR}, Cdouble), + tree, + set, + stat, + var, + targetvalue, + ) +end + +function SCIPtreeBranchVar( + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + branchcand, + eventqueue, + eventfilter, + var, + val, + downchild, + eqchild, + upchild, +) + ccall( + (:SCIPtreeBranchVar, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_VAR}, + Cdouble, + Ptr{Ptr{SCIP_NODE}}, + Ptr{Ptr{SCIP_NODE}}, + Ptr{Ptr{SCIP_NODE}}, + ), + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + branchcand, + eventqueue, + eventfilter, + var, + val, + downchild, + eqchild, + upchild, + ) +end + +function SCIPtreeBranchVarExact( + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + branchcand, + eventqueue, + eventfilter, + var, + downchild, + upchild, +) + ccall( + (:SCIPtreeBranchVarExact, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_VAR}, + Ptr{Ptr{SCIP_NODE}}, + Ptr{Ptr{SCIP_NODE}}, + ), + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + branchcand, + eventqueue, + eventfilter, + var, + downchild, + upchild, + ) +end + +function SCIPtreeBranchVarHole( + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + branchcand, + eventqueue, + eventfilter, + var, + left, + right, + downchild, + upchild, +) + ccall( + (:SCIPtreeBranchVarHole, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Ptr{Ptr{SCIP_NODE}}, + Ptr{Ptr{SCIP_NODE}}, + ), + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + branchcand, + eventqueue, + eventfilter, + var, + left, + right, + downchild, + upchild, + ) +end + +function SCIPtreeBranchVarNary( + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + branchcand, + eventqueue, + eventfilter, + var, + val, + n, + minwidth, + widthfactor, + nchildren, +) + ccall( + (:SCIPtreeBranchVarNary, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_VAR}, + Cdouble, + Cint, + Cdouble, + Cdouble, + Ptr{Cint}, + ), + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + branchcand, + eventqueue, + eventfilter, + var, + val, + n, + minwidth, + widthfactor, + nchildren, + ) end function SCIPtreeAddDiveBoundChange(tree, blkmem, var, dir, value, preferred) - ccall((:SCIPtreeAddDiveBoundChange, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_VAR}, SCIP_BRANCHDIR, Cdouble, Cuint), tree, blkmem, var, dir, value, preferred) -end - -function SCIPtreeGetDiveBoundChangeData(tree, variables, directions, values, ndivebdchgs, preferred) - ccall((:SCIPtreeGetDiveBoundChangeData, libscip), Cvoid, (Ptr{SCIP_TREE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{SCIP_BRANCHDIR}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Cuint), tree, variables, directions, values, ndivebdchgs, preferred) + ccall( + (:SCIPtreeAddDiveBoundChange, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_VAR}, + SCIP_BRANCHDIR, + Cdouble, + Cuint, + ), + tree, + blkmem, + var, + dir, + value, + preferred, + ) +end + +function SCIPtreeGetDiveBoundChangeData( + tree, + variables, + directions, + values, + ndivebdchgs, + preferred, +) + ccall( + (:SCIPtreeGetDiveBoundChangeData, libscip), + Cvoid, + ( + Ptr{SCIP_TREE}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Ptr{SCIP_BRANCHDIR}}, + Ptr{Ptr{Cdouble}}, + Ptr{Cint}, + Cuint, + ), + tree, + variables, + directions, + values, + ndivebdchgs, + preferred, + ) end function SCIPtreeClearDiveBoundChanges(tree) - ccall((:SCIPtreeClearDiveBoundChanges, libscip), Cvoid, (Ptr{SCIP_TREE},), tree) -end - -function SCIPtreeStartProbing(tree, blkmem, set, lp, relaxation, transprob, strongbranching) - ccall((:SCIPtreeStartProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PROB}, Cuint), tree, blkmem, set, lp, relaxation, transprob, strongbranching) + ccall( + (:SCIPtreeClearDiveBoundChanges, libscip), + Cvoid, + (Ptr{SCIP_TREE},), + tree, + ) +end + +function SCIPtreeStartProbing( + tree, + blkmem, + set, + lp, + relaxation, + transprob, + strongbranching, +) + ccall( + (:SCIPtreeStartProbing, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_LP}, + Ptr{SCIP_RELAXATION}, + Ptr{SCIP_PROB}, + Cuint, + ), + tree, + blkmem, + set, + lp, + relaxation, + transprob, + strongbranching, + ) end function SCIPtreeCreateProbingNode(tree, blkmem, set, lp) - ccall((:SCIPtreeCreateProbingNode, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), tree, blkmem, set, lp) -end - -function SCIPtreeSetProbingLPState(tree, blkmem, lp, lpistate, lpinorms, primalfeas, dualfeas) - ccall((:SCIPtreeSetProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}, Ptr{Ptr{SCIP_LPISTATE}}, Ptr{Ptr{SCIP_LPINORMS}}, Cuint, Cuint), tree, blkmem, lp, lpistate, lpinorms, primalfeas, dualfeas) + ccall( + (:SCIPtreeCreateProbingNode, libscip), + SCIP_RETCODE, + (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_LP}), + tree, + blkmem, + set, + lp, + ) +end + +function SCIPtreeSetProbingLPState( + tree, + blkmem, + lp, + lpistate, + lpinorms, + primalfeas, + dualfeas, +) + ccall( + (:SCIPtreeSetProbingLPState, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_LP}, + Ptr{Ptr{SCIP_LPISTATE}}, + Ptr{Ptr{SCIP_LPINORMS}}, + Cuint, + Cuint, + ), + tree, + blkmem, + lp, + lpistate, + lpinorms, + primalfeas, + dualfeas, + ) end function SCIPtreeLoadProbingLPState(tree, blkmem, set, prob, eventqueue, lp) - ccall((:SCIPtreeLoadProbingLPState, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_PROB}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_LP}), tree, blkmem, set, prob, eventqueue, lp) + ccall( + (:SCIPtreeLoadProbingLPState, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_PROB}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_LP}, + ), + tree, + blkmem, + set, + prob, + eventqueue, + lp, + ) end function SCIPtreeMarkProbingNodeHasLP(tree, blkmem, lp) - ccall((:SCIPtreeMarkProbingNodeHasLP, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}), tree, blkmem, lp) -end - -function SCIPtreeBacktrackProbing(tree, reopt, blkmem, set, stat, transprob, origprob, lp, primal, branchcand, eventqueue, eventfilter, cliquetable, probingdepth) - ccall((:SCIPtreeBacktrackProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}, Cint), tree, reopt, blkmem, set, stat, transprob, origprob, lp, primal, branchcand, eventqueue, eventfilter, cliquetable, probingdepth) -end - -function SCIPtreeEndProbing(tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, lp, relaxation, primal, branchcand, eventqueue, eventfilter, cliquetable) - ccall((:SCIPtreeEndProbing, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_REOPT}, Ptr{BMS_BLKMEM}, Ptr{SCIP_SET}, Ptr{SCIP_MESSAGEHDLR}, Ptr{SCIP_STAT}, Ptr{SCIP_PROB}, Ptr{SCIP_PROB}, Ptr{SCIP_LP}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PRIMAL}, Ptr{SCIP_BRANCHCAND}, Ptr{SCIP_EVENTQUEUE}, Ptr{SCIP_EVENTFILTER}, Ptr{SCIP_CLIQUETABLE}), tree, reopt, blkmem, set, messagehdlr, stat, transprob, origprob, lp, relaxation, primal, branchcand, eventqueue, eventfilter, cliquetable) + ccall( + (:SCIPtreeMarkProbingNodeHasLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP_TREE}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LP}), + tree, + blkmem, + lp, + ) +end + +function SCIPtreeBacktrackProbing( + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + primal, + branchcand, + eventqueue, + eventfilter, + cliquetable, + probingdepth, +) + ccall( + (:SCIPtreeBacktrackProbing, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + Cint, + ), + tree, + reopt, + blkmem, + set, + stat, + transprob, + origprob, + lp, + primal, + branchcand, + eventqueue, + eventfilter, + cliquetable, + probingdepth, + ) +end + +function SCIPtreeEndProbing( + tree, + reopt, + blkmem, + set, + messagehdlr, + stat, + transprob, + origprob, + lp, + relaxation, + primal, + branchcand, + eventqueue, + eventfilter, + cliquetable, +) + ccall( + (:SCIPtreeEndProbing, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_TREE}, + Ptr{SCIP_REOPT}, + Ptr{BMS_BLKMEM}, + Ptr{SCIP_SET}, + Ptr{SCIP_MESSAGEHDLR}, + Ptr{SCIP_STAT}, + Ptr{SCIP_PROB}, + Ptr{SCIP_PROB}, + Ptr{SCIP_LP}, + Ptr{SCIP_RELAXATION}, + Ptr{SCIP_PRIMAL}, + Ptr{SCIP_BRANCHCAND}, + Ptr{SCIP_EVENTQUEUE}, + Ptr{SCIP_EVENTFILTER}, + Ptr{SCIP_CLIQUETABLE}, + ), + tree, + reopt, + blkmem, + set, + messagehdlr, + stat, + transprob, + origprob, + lp, + relaxation, + primal, + branchcand, + eventqueue, + eventfilter, + cliquetable, + ) end function SCIPtreeStoreRelaxSol(tree, set, relaxation, transprob) - ccall((:SCIPtreeStoreRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PROB}), tree, set, relaxation, transprob) + ccall( + (:SCIPtreeStoreRelaxSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PROB}), + tree, + set, + relaxation, + transprob, + ) end function SCIPtreeRestoreRelaxSol(tree, set, relaxation, transprob) - ccall((:SCIPtreeRestoreRelaxSol, libscip), SCIP_RETCODE, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PROB}), tree, set, relaxation, transprob) + ccall( + (:SCIPtreeRestoreRelaxSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}, Ptr{SCIP_RELAXATION}, Ptr{SCIP_PROB}), + tree, + set, + relaxation, + transprob, + ) end function SCIPtreeGetNChildren(tree) @@ -14162,7 +41754,12 @@ function SCIPtreeProbing(tree) end function SCIPtreeGetProbingRoot(tree) - ccall((:SCIPtreeGetProbingRoot, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetProbingRoot, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeGetProbingDepth(tree) @@ -14170,7 +41767,12 @@ function SCIPtreeGetProbingDepth(tree) end function SCIPtreeGetFocusNode(tree) - ccall((:SCIPtreeGetFocusNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetFocusNode, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeGetFocusDepth(tree) @@ -14182,11 +41784,22 @@ function SCIPtreeHasFocusNodeLP(tree) end function SCIPtreeSetFocusNodeLP(tree, solvelp) - ccall((:SCIPtreeSetFocusNodeLP, libscip), Cvoid, (Ptr{SCIP_TREE}, Cuint), tree, solvelp) + ccall( + (:SCIPtreeSetFocusNodeLP, libscip), + Cvoid, + (Ptr{SCIP_TREE}, Cuint), + tree, + solvelp, + ) end function SCIPtreeIsFocusNodeLPConstructed(tree) - ccall((:SCIPtreeIsFocusNodeLPConstructed, libscip), Cuint, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeIsFocusNodeLPConstructed, libscip), + Cuint, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeInRepropagation(tree) @@ -14194,7 +41807,12 @@ function SCIPtreeInRepropagation(tree) end function SCIPtreeGetCurrentNode(tree) - ccall((:SCIPtreeGetCurrentNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetCurrentNode, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeGetCurrentDepth(tree) @@ -14206,11 +41824,21 @@ function SCIPtreeHasCurrentNodeLP(tree) end function SCIPtreeGetEffectiveRootDepth(tree) - ccall((:SCIPtreeGetEffectiveRootDepth, libscip), Cint, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetEffectiveRootDepth, libscip), + Cint, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeGetRootNode(tree) - ccall((:SCIPtreeGetRootNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetRootNode, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeProbingObjChanged(tree) @@ -14218,143 +41846,474 @@ function SCIPtreeProbingObjChanged(tree) end function SCIPtreeMarkProbingObjChanged(tree) - ccall((:SCIPtreeMarkProbingObjChanged, libscip), Cvoid, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeMarkProbingObjChanged, libscip), + Cvoid, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeGetPrioChild(tree) - ccall((:SCIPtreeGetPrioChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetPrioChild, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeGetPrioSibling(tree) - ccall((:SCIPtreeGetPrioSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetPrioSibling, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeGetBestChild(tree, set) - ccall((:SCIPtreeGetBestChild, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) + ccall( + (:SCIPtreeGetBestChild, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), + tree, + set, + ) end function SCIPtreeGetBestSibling(tree, set) - ccall((:SCIPtreeGetBestSibling, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) + ccall( + (:SCIPtreeGetBestSibling, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), + tree, + set, + ) end function SCIPtreeGetBestLeaf(tree) - ccall((:SCIPtreeGetBestLeaf, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE},), tree) + ccall( + (:SCIPtreeGetBestLeaf, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE},), + tree, + ) end function SCIPtreeGetBestNode(tree, set) - ccall((:SCIPtreeGetBestNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) + ccall( + (:SCIPtreeGetBestNode, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), + tree, + set, + ) end function SCIPtreeGetLowerbound(tree, set) - ccall((:SCIPtreeGetLowerbound, libscip), Cdouble, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) + ccall( + (:SCIPtreeGetLowerbound, libscip), + Cdouble, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), + tree, + set, + ) end function SCIPtreeGetLowerboundExact(tree, set) - ccall((:SCIPtreeGetLowerboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) + ccall( + (:SCIPtreeGetLowerboundExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), + tree, + set, + ) end function SCIPtreeGetLowerboundNode(tree, set) - ccall((:SCIPtreeGetLowerboundNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), tree, set) + ccall( + (:SCIPtreeGetLowerboundNode, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_TREE}, Ptr{SCIP_SET}), + tree, + set, + ) end function SCIPtreeGetAvgLowerbound(tree, cutoffbound) - ccall((:SCIPtreeGetAvgLowerbound, libscip), Cdouble, (Ptr{SCIP_TREE}, Cdouble), tree, cutoffbound) + ccall( + (:SCIPtreeGetAvgLowerbound, libscip), + Cdouble, + (Ptr{SCIP_TREE}, Cdouble), + tree, + cutoffbound, + ) end function SCIPtreeWasNodeLastBranchParent(tree, node) - ccall((:SCIPtreeWasNodeLastBranchParent, libscip), Cuint, (Ptr{SCIP_TREE}, Ptr{SCIP_NODE}), tree, node) + ccall( + (:SCIPtreeWasNodeLastBranchParent, libscip), + Cuint, + (Ptr{SCIP_TREE}, Ptr{SCIP_NODE}), + tree, + node, + ) end function SCIPincludeConshdlrExactSol(scip) - ccall((:SCIPincludeConshdlrExactSol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrExactSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeConshdlrLinking(scip) - ccall((:SCIPincludeConshdlrLinking, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPcreateConsLinking(scip, cons, name, linkvar, binvars, vals, nbinvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsLinking, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, linkvar, binvars, vals, nbinvars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) -end - -function SCIPcreateConsBasicLinking(scip, cons, name, linkvar, binvars, vals, nbinvars) - ccall((:SCIPcreateConsBasicLinking, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint), scip, cons, name, linkvar, binvars, vals, nbinvars) + ccall( + (:SCIPincludeConshdlrLinking, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPcreateConsLinking( + scip, + cons, + name, + linkvar, + binvars, + vals, + nbinvars, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsLinking, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + linkvar, + binvars, + vals, + nbinvars, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsBasicLinking( + scip, + cons, + name, + linkvar, + binvars, + vals, + nbinvars, +) + ccall( + (:SCIPcreateConsBasicLinking, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cint, + ), + scip, + cons, + name, + linkvar, + binvars, + vals, + nbinvars, + ) end function SCIPexistsConsLinking(scip, linkvar) - ccall((:SCIPexistsConsLinking, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, linkvar) + ccall( + (:SCIPexistsConsLinking, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + linkvar, + ) end function SCIPgetConsLinking(scip, linkvar) - ccall((:SCIPgetConsLinking, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP}, Ptr{SCIP_VAR}), scip, linkvar) + ccall( + (:SCIPgetConsLinking, libscip), + Ptr{SCIP_CONS}, + (Ptr{SCIP}, Ptr{SCIP_VAR}), + scip, + linkvar, + ) end function SCIPgetLinkvarLinking(scip, cons) - ccall((:SCIPgetLinkvarLinking, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetLinkvarLinking, 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) + 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) + ccall( + (:SCIPgetNBinvarsLinking, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetValsLinking(scip, cons) - ccall((:SCIPgetValsLinking, libscip), Ptr{Cdouble}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetValsLinking, libscip), + Ptr{Cdouble}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetBinvarsDataLinking(cons, binvars, vals, nbinvars) - ccall((:SCIPgetBinvarsDataLinking, libscip), SCIP_RETCODE, (Ptr{SCIP_CONS}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}), cons, binvars, vals, nbinvars) + ccall( + (:SCIPgetBinvarsDataLinking, libscip), + SCIP_RETCODE, + (Ptr{SCIP_CONS}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}), + cons, + binvars, + vals, + nbinvars, + ) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, nvars, vars) + ccall( + (:SCIPcreateConsBasicLogicor, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetRowLogicor, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPcreateRowLogicor(scip, cons) - ccall((:SCIPcreateRowLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) -end - -function SCIPcleanupConssLogicor(scip, onlychecked, naddconss, ndelconss, nchgcoefs) - ccall((:SCIPcleanupConssLogicor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, onlychecked, naddconss, ndelconss, nchgcoefs) + ccall( + (:SCIPcreateRowLogicor, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) +end + +function SCIPcleanupConssLogicor( + scip, + onlychecked, + naddconss, + ndelconss, + nchgcoefs, +) + ccall( + (:SCIPcleanupConssLogicor, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), + scip, + onlychecked, + naddconss, + ndelconss, + nchgcoefs, + ) end struct SCIP_ConsNonlinear_Auxexpr - coefs::NTuple{3, Cdouble} + coefs::NTuple{3,Cdouble} cst::Cdouble auxvar::Ptr{SCIP_VAR} underestimate::Cuint @@ -14364,7 +42323,7 @@ end const SCIP_CONSNONLINEAR_AUXEXPR = SCIP_ConsNonlinear_Auxexpr struct __JL_Ctag_88 - data::NTuple{8, UInt8} + data::NTuple{8,UInt8} end function Base.getproperty(x::Ptr{__JL_Ctag_88}, f::Symbol) @@ -14384,16 +42343,16 @@ function Base.setproperty!(x::Ptr{__JL_Ctag_88}, f::Symbol, v) unsafe_store!(getproperty(x, f), v) end -function Base.propertynames(x::__JL_Ctag_88, private::Bool = false) +function Base.propertynames(x::__JL_Ctag_88, private::Bool=false) (:exprs, :var, if private - fieldnames(typeof(x)) - else - () - end...) + fieldnames(typeof(x)) + else + () + end...) end struct SCIP_ConsNonlinear_BilinTerm - data::NTuple{48, UInt8} + data::NTuple{48,UInt8} end function Base.getproperty(x::Ptr{SCIP_ConsNonlinear_BilinTerm}, f::Symbol) @@ -14419,110 +42378,625 @@ function Base.setproperty!(x::Ptr{SCIP_ConsNonlinear_BilinTerm}, f::Symbol, v) unsafe_store!(getproperty(x, f), v) end -function Base.propertynames(x::SCIP_ConsNonlinear_BilinTerm, private::Bool = false) - (:x, :y, :aux, :nauxexprs, :auxexprssize, :nlockspos, :nlocksneg, :existing, if private +function Base.propertynames( + x::SCIP_ConsNonlinear_BilinTerm, + private::Bool=false, +) + ( + :x, + :y, + :aux, + :nauxexprs, + :auxexprssize, + :nlockspos, + :nlocksneg, + :existing, + if private fieldnames(typeof(x)) else () - end...) + end..., + ) end const SCIP_CONSNONLINEAR_BILINTERM = SCIP_ConsNonlinear_BilinTerm function SCIPincludeConshdlrNonlinear(scip) - ccall((:SCIPincludeConshdlrNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPincludeConsUpgradeNonlinear(scip, nlconsupgd, priority, active, conshdlrname) - ccall((:SCIPincludeConsUpgradeNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cvoid}, Cint, Cuint, Ptr{Cchar}), scip, nlconsupgd, priority, active, conshdlrname) -end - -function SCIPcreateConsNonlinear(scip, cons, name, expr, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) - ccall((:SCIPcreateConsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_EXPR}, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, expr, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) + ccall( + (:SCIPincludeConshdlrNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPincludeConsUpgradeNonlinear( + scip, + nlconsupgd, + priority, + active, + conshdlrname, +) + ccall( + (:SCIPincludeConsUpgradeNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cvoid}, Cint, Cuint, Ptr{Cchar}), + scip, + nlconsupgd, + priority, + active, + conshdlrname, + ) +end + +function SCIPcreateConsNonlinear( + scip, + cons, + name, + expr, + lhs, + rhs, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, +) + ccall( + (:SCIPcreateConsNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_EXPR}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + expr, + lhs, + rhs, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + ) end function SCIPcreateConsBasicNonlinear(scip, cons, name, expr, lhs, rhs) - ccall((:SCIPcreateConsBasicNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_EXPR}, Cdouble, Cdouble), scip, cons, name, expr, lhs, rhs) -end - -function SCIPcreateConsQuadraticNonlinear(scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) - ccall((:SCIPcreateConsQuadraticNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable) -end - -function SCIPcreateConsBasicQuadraticNonlinear(scip, cons, name, nlinvars, linvars, lincoefs, nquadterms, quadvars1, quadvars2, quadcoefs, lhs, rhs) - ccall((:SCIPcreateConsBasicQuadraticNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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 SCIPcreateConsBasicSOCNonlinear(scip, cons, name, nvars, vars, coefs, offsets, constant, rhsvar, rhscoeff, rhsoffset) - ccall((:SCIPcreateConsBasicSOCNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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 SCIPcreateConsBasicSignpowerNonlinear(scip, cons, name, x, z, exponent, xoffset, zcoef, lhs, rhs) - ccall((:SCIPcreateConsBasicSignpowerNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble), scip, cons, name, x, z, exponent, xoffset, zcoef, lhs, rhs) + ccall( + (:SCIPcreateConsBasicNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_EXPR}, + Cdouble, + Cdouble, + ), + scip, + cons, + name, + expr, + lhs, + rhs, + ) +end + +function SCIPcreateConsQuadraticNonlinear( + scip, + cons, + name, + nlinvars, + linvars, + lincoefs, + nquadterms, + quadvars1, + quadvars2, + quadcoefs, + lhs, + rhs, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, +) + ccall( + (:SCIPcreateConsQuadraticNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + nlinvars, + linvars, + lincoefs, + nquadterms, + quadvars1, + quadvars2, + quadcoefs, + lhs, + rhs, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + ) +end + +function SCIPcreateConsBasicQuadraticNonlinear( + scip, + cons, + name, + nlinvars, + linvars, + lincoefs, + nquadterms, + quadvars1, + quadvars2, + quadcoefs, + lhs, + rhs, +) + ccall( + (:SCIPcreateConsBasicQuadraticNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + 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 SCIPcreateConsBasicSOCNonlinear( + scip, + cons, + name, + nvars, + vars, + coefs, + offsets, + constant, + rhsvar, + rhscoeff, + rhsoffset, +) + ccall( + (:SCIPcreateConsBasicSOCNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + 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 SCIPcreateConsBasicSignpowerNonlinear( + scip, + cons, + name, + x, + z, + exponent, + xoffset, + zcoef, + lhs, + rhs, +) + ccall( + (:SCIPcreateConsBasicSignpowerNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + ), + scip, + cons, + name, + x, + z, + exponent, + xoffset, + zcoef, + lhs, + rhs, + ) end function SCIPgetCurBoundsTagNonlinear(conshdlr) - ccall((:SCIPgetCurBoundsTagNonlinear, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPgetCurBoundsTagNonlinear, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPgetLastBoundRelaxTagNonlinear(conshdlr) - ccall((:SCIPgetLastBoundRelaxTagNonlinear, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPgetLastBoundRelaxTagNonlinear, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPincrementCurBoundsTagNonlinear(conshdlr, boundrelax) - ccall((:SCIPincrementCurBoundsTagNonlinear, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Cuint), conshdlr, boundrelax) + ccall( + (:SCIPincrementCurBoundsTagNonlinear, libscip), + Cvoid, + (Ptr{SCIP_CONSHDLR}, Cuint), + conshdlr, + boundrelax, + ) end function SCIPgetVarExprHashmapNonlinear(conshdlr) - ccall((:SCIPgetVarExprHashmapNonlinear, libscip), Ptr{SCIP_HASHMAP}, (Ptr{SCIP_CONSHDLR},), conshdlr) -end - -function SCIPprocessRowprepNonlinear(scip, nlhdlr, cons, expr, rowprep, overestimate, auxvar, auxvalue, allowweakcuts, branchscoresuccess, inenforcement, sol, result) - ccall((:SCIPprocessRowprepNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLHDLR}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}, Ptr{SCIP_ROWPREP}, Cuint, Ptr{SCIP_VAR}, Cdouble, Cuint, Cuint, Cuint, Ptr{SCIP_SOL}, Ptr{SCIP_RESULT}), scip, nlhdlr, cons, expr, rowprep, overestimate, auxvar, auxvalue, allowweakcuts, branchscoresuccess, inenforcement, sol, result) + ccall( + (:SCIPgetVarExprHashmapNonlinear, libscip), + Ptr{SCIP_HASHMAP}, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) +end + +function SCIPprocessRowprepNonlinear( + scip, + nlhdlr, + cons, + expr, + rowprep, + overestimate, + auxvar, + auxvalue, + allowweakcuts, + branchscoresuccess, + inenforcement, + sol, + result, +) + ccall( + (:SCIPprocessRowprepNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLHDLR}, + Ptr{SCIP_CONS}, + Ptr{SCIP_EXPR}, + Ptr{SCIP_ROWPREP}, + Cuint, + Ptr{SCIP_VAR}, + Cdouble, + Cuint, + Cuint, + Cuint, + Ptr{SCIP_SOL}, + Ptr{SCIP_RESULT}, + ), + scip, + nlhdlr, + cons, + expr, + rowprep, + overestimate, + auxvar, + auxvalue, + allowweakcuts, + branchscoresuccess, + inenforcement, + sol, + result, + ) end function SCIPassumeConvexNonlinear(conshdlr) - ccall((:SCIPassumeConvexNonlinear, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPassumeConvexNonlinear, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPcollectBilinTermsNonlinear(scip, conshdlr, conss, nconss) - ccall((:SCIPcollectBilinTermsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Ptr{SCIP_CONS}}, Cint), scip, conshdlr, conss, nconss) + ccall( + (:SCIPcollectBilinTermsNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{Ptr{SCIP_CONS}}, Cint), + scip, + conshdlr, + conss, + nconss, + ) end function SCIPgetNBilinTermsNonlinear(conshdlr) - ccall((:SCIPgetNBilinTermsNonlinear, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPgetNBilinTermsNonlinear, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPgetBilinTermsNonlinear(conshdlr) - ccall((:SCIPgetBilinTermsNonlinear, libscip), Ptr{SCIP_CONSNONLINEAR_BILINTERM}, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPgetBilinTermsNonlinear, libscip), + Ptr{SCIP_CONSNONLINEAR_BILINTERM}, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPgetBilinTermIdxNonlinear(conshdlr, x, y) - ccall((:SCIPgetBilinTermIdxNonlinear, libscip), Cint, (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), conshdlr, x, y) + ccall( + (:SCIPgetBilinTermIdxNonlinear, libscip), + Cint, + (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), + conshdlr, + x, + y, + ) end function SCIPgetBilinTermNonlinear(conshdlr, x, y) - ccall((:SCIPgetBilinTermNonlinear, libscip), Ptr{SCIP_CONSNONLINEAR_BILINTERM}, (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), conshdlr, x, y) + ccall( + (:SCIPgetBilinTermNonlinear, libscip), + Ptr{SCIP_CONSNONLINEAR_BILINTERM}, + (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), + conshdlr, + x, + y, + ) end function SCIPevalBilinAuxExprNonlinear(scip, x, y, auxexpr, sol) - ccall((:SCIPevalBilinAuxExprNonlinear, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Ptr{SCIP_CONSNONLINEAR_AUXEXPR}, Ptr{SCIP_SOL}), scip, x, y, auxexpr, sol) -end - -function SCIPinsertBilinearTermExistingNonlinear(scip, conshdlr, x, y, auxvar, nlockspos, nlocksneg) - ccall((:SCIPinsertBilinearTermExistingNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cint, Cint), scip, conshdlr, x, y, auxvar, nlockspos, nlocksneg) -end - -function SCIPinsertBilinearTermImplicitNonlinear(scip, conshdlr, x, y, auxvar, coefx, coefy, coefaux, cst, overestimate) - ccall((:SCIPinsertBilinearTermImplicitNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cdouble, Cuint), scip, conshdlr, x, y, auxvar, coefx, coefy, coefaux, cst, overestimate) -end - -function SCIPcomputeFacetVertexPolyhedralNonlinear(scip, conshdlr, overestimate, _function, fundata, xstar, box, nallvars, targetvalue, success, facetcoefs, facetconstant) - ccall((:SCIPcomputeFacetVertexPolyhedralNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cdouble}, Ptr{Cdouble}, Cint, Cdouble, Ptr{Cuint}, Ptr{Cdouble}, Ptr{Cdouble}), scip, conshdlr, overestimate, _function, fundata, xstar, box, nallvars, targetvalue, success, facetcoefs, facetconstant) + ccall( + (:SCIPevalBilinAuxExprNonlinear, libscip), + Cdouble, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Ptr{SCIP_CONSNONLINEAR_AUXEXPR}, + Ptr{SCIP_SOL}, + ), + scip, + x, + y, + auxexpr, + sol, + ) +end + +function SCIPinsertBilinearTermExistingNonlinear( + scip, + conshdlr, + x, + y, + auxvar, + nlockspos, + nlocksneg, +) + ccall( + (:SCIPinsertBilinearTermExistingNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_CONSHDLR}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Cint, + Cint, + ), + scip, + conshdlr, + x, + y, + auxvar, + nlockspos, + nlocksneg, + ) +end + +function SCIPinsertBilinearTermImplicitNonlinear( + scip, + conshdlr, + x, + y, + auxvar, + coefx, + coefy, + coefaux, + cst, + overestimate, +) + ccall( + (:SCIPinsertBilinearTermImplicitNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_CONSHDLR}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cuint, + ), + scip, + conshdlr, + x, + y, + auxvar, + coefx, + coefy, + coefaux, + cst, + overestimate, + ) +end + +function SCIPcomputeFacetVertexPolyhedralNonlinear( + scip, + conshdlr, + overestimate, + _function, + fundata, + xstar, + box, + nallvars, + targetvalue, + success, + facetcoefs, + facetconstant, +) + ccall( + (:SCIPcomputeFacetVertexPolyhedralNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_CONSHDLR}, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Cint, + Cdouble, + Ptr{Cuint}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + scip, + conshdlr, + overestimate, + _function, + fundata, + xstar, + box, + nallvars, + targetvalue, + success, + facetcoefs, + facetconstant, + ) end function SCIPgetExprNonlinear(cons) - ccall((:SCIPgetExprNonlinear, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_CONS},), cons) + ccall( + (:SCIPgetExprNonlinear, libscip), + Ptr{SCIP_EXPR}, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPgetLhsNonlinear(cons) @@ -14534,203 +43008,820 @@ function SCIPgetRhsNonlinear(cons) end function SCIPgetNlRowNonlinear(scip, cons, nlrow) - ccall((:SCIPgetNlRowNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_NLROW}}), scip, cons, nlrow) + ccall( + (:SCIPgetNlRowNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_NLROW}}), + scip, + cons, + nlrow, + ) end function SCIPgetCurvatureNonlinear(cons) - ccall((:SCIPgetCurvatureNonlinear, libscip), SCIP_EXPRCURV, (Ptr{SCIP_CONS},), cons) + ccall( + (:SCIPgetCurvatureNonlinear, libscip), + SCIP_EXPRCURV, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPcheckQuadraticNonlinear(scip, cons, isquadratic) - ccall((:SCIPcheckQuadraticNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, isquadratic) + ccall( + (:SCIPcheckQuadraticNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), + scip, + cons, + isquadratic, + ) end function SCIPchgLhsNonlinear(scip, cons, lhs) - ccall((:SCIPchgLhsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, lhs) + ccall( + (:SCIPchgLhsNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), + scip, + cons, + lhs, + ) end function SCIPchgRhsNonlinear(scip, cons, rhs) - ccall((:SCIPchgRhsNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), scip, cons, rhs) + ccall( + (:SCIPchgRhsNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Cdouble), + scip, + cons, + rhs, + ) end function SCIPchgExprNonlinear(scip, cons, expr) - ccall((:SCIPchgExprNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}), scip, cons, expr) + ccall( + (:SCIPchgExprNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}), + scip, + cons, + expr, + ) 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) + ccall( + (:SCIPaddLinearVarNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), + scip, + cons, + var, + coef, + ) end function SCIPaddExprNonlinear(scip, cons, expr, coef) - ccall((:SCIPaddExprNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}, Cdouble), scip, cons, expr, coef) + ccall( + (:SCIPaddExprNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_EXPR}, Cdouble), + scip, + cons, + expr, + coef, + ) end function SCIPgetAbsViolationNonlinear(scip, cons, sol, viol) - ccall((:SCIPgetAbsViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, viol) + ccall( + (:SCIPgetAbsViolationNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), + scip, + cons, + sol, + viol, + ) end function SCIPgetRelViolationNonlinear(scip, cons, sol, viol) - ccall((:SCIPgetRelViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, viol) + ccall( + (:SCIPgetRelViolationNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), + scip, + cons, + sol, + viol, + ) end function SCIPgetLinvarMayDecreaseNonlinear(scip, cons, var, coef) - ccall((:SCIPgetLinvarMayDecreaseNonlinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, var, coef) + ccall( + (:SCIPgetLinvarMayDecreaseNonlinear, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), + scip, + cons, + var, + coef, + ) end function SCIPgetLinvarMayIncreaseNonlinear(scip, cons, var, coef) - ccall((:SCIPgetLinvarMayIncreaseNonlinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, var, coef) + ccall( + (:SCIPgetLinvarMayIncreaseNonlinear, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), + scip, + cons, + var, + coef, + ) end function SCIPgetExprNLocksPosNonlinear(expr) - ccall((:SCIPgetExprNLocksPosNonlinear, libscip), Cint, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPgetExprNLocksPosNonlinear, libscip), + Cint, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPgetExprNLocksNegNonlinear(expr) - ccall((:SCIPgetExprNLocksNegNonlinear, libscip), Cint, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPgetExprNLocksNegNonlinear, libscip), + Cint, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPgetExprAuxVarNonlinear(expr) - ccall((:SCIPgetExprAuxVarNonlinear, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPgetExprAuxVarNonlinear, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPgetExprNEnfosNonlinear(expr) ccall((:SCIPgetExprNEnfosNonlinear, libscip), Cint, (Ptr{SCIP_EXPR},), expr) end -function SCIPgetExprEnfoDataNonlinear(expr, idx, nlhdlr, nlhdlrexprdata, nlhdlrparticipation, sepabelowusesactivity, sepaaboveusesactivity, auxvalue) - ccall((:SCIPgetExprEnfoDataNonlinear, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint, Ptr{Ptr{SCIP_NLHDLR}}, Ptr{Ptr{SCIP_NLHDLREXPRDATA}}, Ptr{SCIP_NLHDLR_METHOD}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cdouble}), expr, idx, nlhdlr, nlhdlrexprdata, nlhdlrparticipation, sepabelowusesactivity, sepaaboveusesactivity, auxvalue) +function SCIPgetExprEnfoDataNonlinear( + expr, + idx, + nlhdlr, + nlhdlrexprdata, + nlhdlrparticipation, + sepabelowusesactivity, + sepaaboveusesactivity, + auxvalue, +) + ccall( + (:SCIPgetExprEnfoDataNonlinear, libscip), + Cvoid, + ( + Ptr{SCIP_EXPR}, + Cint, + Ptr{Ptr{SCIP_NLHDLR}}, + Ptr{Ptr{SCIP_NLHDLREXPRDATA}}, + Ptr{SCIP_NLHDLR_METHOD}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cdouble}, + ), + expr, + idx, + nlhdlr, + nlhdlrexprdata, + nlhdlrparticipation, + sepabelowusesactivity, + sepaaboveusesactivity, + auxvalue, + ) end function SCIPsetExprEnfoAuxValueNonlinear(expr, idx, auxvalue) - ccall((:SCIPsetExprEnfoAuxValueNonlinear, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint, Cdouble), expr, idx, auxvalue) + ccall( + (:SCIPsetExprEnfoAuxValueNonlinear, libscip), + Cvoid, + (Ptr{SCIP_EXPR}, Cint, Cdouble), + expr, + idx, + auxvalue, + ) end function SCIPgetExprNPropUsesActivityNonlinear(expr) - ccall((:SCIPgetExprNPropUsesActivityNonlinear, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPgetExprNPropUsesActivityNonlinear, libscip), + Cuint, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPgetExprNSepaUsesActivityNonlinear(expr) - ccall((:SCIPgetExprNSepaUsesActivityNonlinear, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPgetExprNSepaUsesActivityNonlinear, libscip), + Cuint, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPgetExprNAuxvarUsesNonlinear(expr) - ccall((:SCIPgetExprNAuxvarUsesNonlinear, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) -end - -function SCIPregisterExprUsageNonlinear(scip, expr, useauxvar, useactivityforprop, useactivityforsepabelow, useactivityforsepaabove) - ccall((:SCIPregisterExprUsageNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cuint, Cuint, Cuint, Cuint), scip, expr, useauxvar, useactivityforprop, useactivityforsepabelow, useactivityforsepaabove) + ccall( + (:SCIPgetExprNAuxvarUsesNonlinear, libscip), + Cuint, + (Ptr{SCIP_EXPR},), + expr, + ) +end + +function SCIPregisterExprUsageNonlinear( + scip, + expr, + useauxvar, + useactivityforprop, + useactivityforsepabelow, + useactivityforsepaabove, +) + ccall( + (:SCIPregisterExprUsageNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cuint, Cuint, Cuint, Cuint), + scip, + expr, + useauxvar, + useactivityforprop, + useactivityforsepabelow, + useactivityforsepaabove, + ) end function SCIPgetExprActivityNonlinear(scip, cons, sol, activity) - ccall((:SCIPgetExprActivityNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), scip, cons, sol, activity) -end - -function SCIPgetExprAbsOrigViolationNonlinear(scip, expr, sol, soltag, viol, violunder, violover) - ccall((:SCIPgetExprAbsOrigViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}, Clonglong, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}), scip, expr, sol, soltag, viol, violunder, violover) -end - -function SCIPgetExprAbsAuxViolationNonlinear(scip, expr, auxvalue, sol, viol, violunder, violover) - ccall((:SCIPgetExprAbsAuxViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cdouble, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}), scip, expr, auxvalue, sol, viol, violunder, violover) -end - -function SCIPgetExprRelAuxViolationNonlinear(scip, expr, auxvalue, sol, viol, violunder, violover) - ccall((:SCIPgetExprRelAuxViolationNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cdouble, Ptr{SCIP_SOL}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}), scip, expr, auxvalue, sol, viol, violunder, violover) + ccall( + (:SCIPgetExprActivityNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_SOL}, Ptr{Cdouble}), + scip, + cons, + sol, + activity, + ) +end + +function SCIPgetExprAbsOrigViolationNonlinear( + scip, + expr, + sol, + soltag, + viol, + violunder, + violover, +) + ccall( + (:SCIPgetExprAbsOrigViolationNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Ptr{SCIP_SOL}, + Clonglong, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + expr, + sol, + soltag, + viol, + violunder, + violover, + ) +end + +function SCIPgetExprAbsAuxViolationNonlinear( + scip, + expr, + auxvalue, + sol, + viol, + violunder, + violover, +) + ccall( + (:SCIPgetExprAbsAuxViolationNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Cdouble, + Ptr{SCIP_SOL}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + expr, + auxvalue, + sol, + viol, + violunder, + violover, + ) +end + +function SCIPgetExprRelAuxViolationNonlinear( + scip, + expr, + auxvalue, + sol, + viol, + violunder, + violover, +) + ccall( + (:SCIPgetExprRelAuxViolationNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + Cdouble, + Ptr{SCIP_SOL}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + expr, + auxvalue, + sol, + viol, + violunder, + violover, + ) end function SCIPgetExprBoundsNonlinear(scip, expr) - ccall((:SCIPgetExprBoundsNonlinear, libscip), SCIP_INTERVAL, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) -end - -function SCIPtightenExprIntervalNonlinear(scip, expr, newbounds, cutoff, ntightenings) - ccall((:SCIPtightenExprIntervalNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_INTERVAL, Ptr{Cuint}, Ptr{Cint}), scip, expr, newbounds, cutoff, ntightenings) + ccall( + (:SCIPgetExprBoundsNonlinear, libscip), + SCIP_INTERVAL, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) +end + +function SCIPtightenExprIntervalNonlinear( + scip, + expr, + newbounds, + cutoff, + ntightenings, +) + ccall( + (:SCIPtightenExprIntervalNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_INTERVAL, Ptr{Cuint}, Ptr{Cint}), + scip, + expr, + newbounds, + cutoff, + ntightenings, + ) end function SCIPmarkExprPropagateNonlinear(scip, expr) - ccall((:SCIPmarkExprPropagateNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPmarkExprPropagateNonlinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPaddExprViolScoreNonlinear(scip, expr, violscore) - ccall((:SCIPaddExprViolScoreNonlinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cdouble), scip, expr, violscore) -end - -function SCIPaddExprsViolScoreNonlinear(scip, exprs, nexprs, violscore, sol, success) - ccall((:SCIPaddExprsViolScoreNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Cdouble, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, exprs, nexprs, violscore, sol, success) + ccall( + (:SCIPaddExprViolScoreNonlinear, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Cdouble), + scip, + expr, + violscore, + ) +end + +function SCIPaddExprsViolScoreNonlinear( + scip, + exprs, + nexprs, + violscore, + sol, + success, +) + ccall( + (:SCIPaddExprsViolScoreNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Cint, + Cdouble, + Ptr{SCIP_SOL}, + Ptr{Cuint}, + ), + scip, + exprs, + nexprs, + violscore, + sol, + success, + ) end function SCIPgetExprViolScoreNonlinear(expr) - ccall((:SCIPgetExprViolScoreNonlinear, libscip), Cdouble, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPgetExprViolScoreNonlinear, libscip), + Cdouble, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPgetExprPartialDiffNonlinear(scip, expr, var) - ccall((:SCIPgetExprPartialDiffNonlinear, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_VAR}), scip, expr, var) + ccall( + (:SCIPgetExprPartialDiffNonlinear, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_VAR}), + scip, + expr, + var, + ) end function SCIPgetExprPartialDiffGradientDirNonlinear(scip, expr, var) - ccall((:SCIPgetExprPartialDiffGradientDirNonlinear, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_VAR}), scip, expr, var) + ccall( + (:SCIPgetExprPartialDiffGradientDirNonlinear, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_VAR}), + scip, + expr, + var, + ) end function SCIPevalExprQuadraticAuxNonlinear(scip, expr, sol) - ccall((:SCIPevalExprQuadraticAuxNonlinear, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}), scip, expr, sol) -end - -function SCIPincludeNlhdlrNonlinear(scip, nlhdlr, name, desc, detectpriority, enfopriority, detect, evalaux, nlhdlrdata) - ccall((:SCIPincludeNlhdlrNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_NLHDLR}}, Ptr{Cchar}, Ptr{Cchar}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_NLHDLRDATA}), scip, nlhdlr, name, desc, detectpriority, enfopriority, detect, evalaux, nlhdlrdata) + ccall( + (:SCIPevalExprQuadraticAuxNonlinear, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_SOL}), + scip, + expr, + sol, + ) +end + +function SCIPincludeNlhdlrNonlinear( + scip, + nlhdlr, + name, + desc, + detectpriority, + enfopriority, + detect, + evalaux, + nlhdlrdata, +) + ccall( + (:SCIPincludeNlhdlrNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_NLHDLR}}, + Ptr{Cchar}, + Ptr{Cchar}, + Cint, + Cint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{SCIP_NLHDLRDATA}, + ), + scip, + nlhdlr, + name, + desc, + detectpriority, + enfopriority, + detect, + evalaux, + nlhdlrdata, + ) end function SCIPgetNNlhdlrsNonlinear(conshdlr) - ccall((:SCIPgetNNlhdlrsNonlinear, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPgetNNlhdlrsNonlinear, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPgetNlhdlrsNonlinear(conshdlr) - ccall((:SCIPgetNlhdlrsNonlinear, libscip), Ptr{Ptr{SCIP_NLHDLR}}, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPgetNlhdlrsNonlinear, libscip), + Ptr{Ptr{SCIP_NLHDLR}}, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPfindNlhdlrNonlinear(conshdlr, name) - ccall((:SCIPfindNlhdlrNonlinear, libscip), Ptr{SCIP_NLHDLR}, (Ptr{SCIP_CONSHDLR}, Ptr{Cchar}), conshdlr, name) + ccall( + (:SCIPfindNlhdlrNonlinear, libscip), + Ptr{SCIP_NLHDLR}, + (Ptr{SCIP_CONSHDLR}, Ptr{Cchar}), + conshdlr, + name, + ) end function SCIPgetNlhdlrExprDataNonlinear(nlhdlr, expr) - ccall((:SCIPgetNlhdlrExprDataNonlinear, libscip), Ptr{SCIP_NLHDLREXPRDATA}, (Ptr{SCIP_NLHDLR}, Ptr{SCIP_EXPR}), nlhdlr, expr) + ccall( + (:SCIPgetNlhdlrExprDataNonlinear, libscip), + Ptr{SCIP_NLHDLREXPRDATA}, + (Ptr{SCIP_NLHDLR}, Ptr{SCIP_EXPR}), + nlhdlr, + expr, + ) end 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, resvar, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, resvar, nvars, vars) + ccall( + (:SCIPcreateConsBasicOr, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + 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) + 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) + 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) + ccall( + (:SCIPgetResultantOr, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPincludeConshdlrOrbisack(scip) - ccall((:SCIPincludeConshdlrOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -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, Cuint, Ptr{Cuint}), scip, sol, vars1, vars2, nrows, printreason, feasible) -end - -function SCIPcreateConsOrbisack(scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) -end - -function SCIPcreateConsBasicOrbisack(scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, ismodelcons) - ccall((:SCIPcreateConsBasicOrbisack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cuint, Cuint), scip, cons, name, vars1, vars2, nrows, ispporbisack, isparttype, ismodelcons) + ccall( + (:SCIPincludeConshdlrOrbisack, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +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, + Cuint, + Ptr{Cuint}, + ), + scip, + sol, + vars1, + vars2, + nrows, + printreason, + feasible, + ) +end + +function SCIPcreateConsOrbisack( + scip, + cons, + name, + vars1, + vars2, + nrows, + ispporbisack, + isparttype, + ismodelcons, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsOrbisack, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + vars1, + vars2, + nrows, + ispporbisack, + isparttype, + ismodelcons, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsBasicOrbisack( + scip, + cons, + name, + vars1, + vars2, + nrows, + ispporbisack, + isparttype, + ismodelcons, +) + ccall( + (:SCIPcreateConsBasicOrbisack, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + vars1, + vars2, + nrows, + ispporbisack, + isparttype, + ismodelcons, + ) end const SYM_SPEC = UInt32 @@ -14806,19 +43897,131 @@ end const SCIP_ORBITOPETYPE = SCIP_OrbitopeType function SCIPincludeConshdlrOrbitope(scip) - ccall((:SCIPincludeConshdlrOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPcreateConsOrbitope(scip, cons, name, vars, orbitopetype, nrows, ncols, resolveprop, ismodelcons, checkpporbitope, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{Ptr{SCIP_VAR}}}, SCIP_ORBITOPETYPE, Cint, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, vars, orbitopetype, nrows, ncols, resolveprop, ismodelcons, checkpporbitope, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) -end - -function SCIPcreateConsBasicOrbitope(scip, cons, name, vars, orbitopetype, nrows, ncols, resolveprop, ismodelcons, checkpporbitope) - ccall((:SCIPcreateConsBasicOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{Ptr{SCIP_VAR}}}, SCIP_ORBITOPETYPE, Cint, Cint, Cuint, Cuint, Cuint), scip, cons, name, vars, orbitopetype, nrows, ncols, resolveprop, ismodelcons, checkpporbitope) + ccall( + (:SCIPincludeConshdlrOrbitope, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPcreateConsOrbitope( + scip, + cons, + name, + vars, + orbitopetype, + nrows, + ncols, + resolveprop, + ismodelcons, + checkpporbitope, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsOrbitope, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + SCIP_ORBITOPETYPE, + Cint, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + vars, + orbitopetype, + nrows, + ncols, + resolveprop, + ismodelcons, + checkpporbitope, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsBasicOrbitope( + scip, + cons, + name, + vars, + orbitopetype, + nrows, + ncols, + resolveprop, + ismodelcons, + checkpporbitope, +) + ccall( + (:SCIPcreateConsBasicOrbitope, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + SCIP_ORBITOPETYPE, + Cint, + Cint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + vars, + orbitopetype, + nrows, + ncols, + resolveprop, + ismodelcons, + checkpporbitope, + ) end function SCIPincludeConshdlrPseudoboolean(scip) - ccall((:SCIPincludeConshdlrPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrPseudoboolean, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end @enum SCIP_LinearConsType::Int32 begin @@ -14831,72 +44034,393 @@ end const SCIP_LINEARCONSTYPE = SCIP_LinearConsType -function SCIPcreateConsPseudobooleanWithConss(scip, cons, name, lincons, linconstype, andconss, andcoefs, nandconss, indvar, weight, issoftcons, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsPseudobooleanWithConss, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{SCIP_CONS}, SCIP_LINEARCONSTYPE, Ptr{Ptr{SCIP_CONS}}, Ptr{Cdouble}, Cint, Ptr{SCIP_VAR}, Cdouble, Cuint, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, lincons, linconstype, andconss, andcoefs, nandconss, indvar, weight, issoftcons, 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, lhs, rhs, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cdouble}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_VAR}, Cdouble, Cuint, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, linvars, nlinvars, linvals, terms, nterms, ntermvars, termvals, indvar, weight, issoftcons, 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, lhs, rhs) - ccall((:SCIPcreateConsBasicPseudoboolean, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cdouble}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{SCIP_VAR}, Cdouble, Cuint, Cdouble, Cdouble), scip, cons, name, linvars, nlinvars, linvals, terms, nterms, ntermvars, termvals, indvar, weight, issoftcons, lhs, rhs) +function SCIPcreateConsPseudobooleanWithConss( + scip, + cons, + name, + lincons, + linconstype, + andconss, + andcoefs, + nandconss, + indvar, + weight, + issoftcons, + lhs, + rhs, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsPseudobooleanWithConss, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{SCIP_CONS}, + SCIP_LINEARCONSTYPE, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cdouble}, + Cint, + Ptr{SCIP_VAR}, + Cdouble, + Cuint, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + lincons, + linconstype, + andconss, + andcoefs, + nandconss, + indvar, + weight, + issoftcons, + 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, + lhs, + rhs, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsPseudoboolean, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Cdouble}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{SCIP_VAR}, + Cdouble, + Cuint, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + linvars, + nlinvars, + linvals, + terms, + nterms, + ntermvars, + termvals, + indvar, + weight, + issoftcons, + 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, + lhs, + rhs, +) + ccall( + (:SCIPcreateConsBasicPseudoboolean, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Cdouble}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Ptr{SCIP_VAR}, + Cdouble, + Cuint, + Cdouble, + Cdouble, + ), + scip, + cons, + name, + linvars, + nlinvars, + linvals, + terms, + nterms, + ntermvars, + termvals, + indvar, + weight, + issoftcons, + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetRhsPseudoboolean, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPincludeConshdlrSetppc(scip) - ccall((:SCIPincludeConshdlrSetppc, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrSetppc, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end @enum SCIP_SetppcType::UInt32 begin @@ -14907,108 +44431,482 @@ end const SCIP_SETPPCTYPE = SCIP_SetppcType -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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall( + (:SCIPcreateConsBasicSetpart, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) + ccall( + (:SCIPcreateConsBasicSetpack, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, nvars, vars) + ccall( + (:SCIPcreateConsBasicSetcover, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, 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) + 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetRowSetppc, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPcreateRowSetppc(scip, cons) - ccall((:SCIPcreateRowSetppc, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPcreateRowSetppc, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetNFixedonesSetppc(scip, cons) - ccall((:SCIPgetNFixedonesSetppc, libscip), Cint, (Ptr{SCIP}, Ptr{SCIP_CONS}), 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 - -function SCIPcleanupConssSetppc(scip, onlychecked, infeasible, naddconss, ndelconss, nchgcoefs, nfixedvars) - ccall((:SCIPcleanupConssSetppc, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, onlychecked, infeasible, naddconss, ndelconss, nchgcoefs, nfixedvars) + ccall( + (:SCIPgetNFixedzerosSetppc, libscip), + Cint, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) +end + +function SCIPcleanupConssSetppc( + scip, + onlychecked, + infeasible, + naddconss, + ndelconss, + nchgcoefs, + nfixedvars, +) + ccall( + (:SCIPcleanupConssSetppc, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cuint, + Ptr{Cuint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + onlychecked, + infeasible, + naddconss, + ndelconss, + nchgcoefs, + nfixedvars, + ) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, weights, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, name, nvars, vars, weights) + ccall( + (:SCIPcreateConsBasicSOS1, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetConflictgraphSOS1, libscip), + Ptr{SCIP_DIGRAPH}, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPgetNSOS1Vars(conshdlr) @@ -15016,179 +44914,816 @@ function SCIPgetNSOS1Vars(conshdlr) end function SCIPvarIsSOS1(conshdlr, var) - ccall((:SCIPvarIsSOS1, libscip), Cuint, (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_VAR}), conshdlr, var) + ccall( + (:SCIPvarIsSOS1, libscip), + Cuint, + (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) + 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) + 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{Cuint}, Ptr{Cuint}), scip, conshdlr, sol, changed, success) + ccall( + (:SCIPmakeSOS1sFeasible, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONSHDLR}, Ptr{SCIP_SOL}, Ptr{Cuint}, Ptr{Cuint}), + scip, + conshdlr, + sol, + changed, + success, + ) end 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, nvars, vars, weights, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) +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}}, + Ptr{Cchar}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, cons, name, nvars, vars, weights) + ccall( + (:SCIPcreateConsBasicSOS2, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetWeightsSOS2, libscip), + Ptr{Cdouble}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, binvar, slackcons, initial, separate, enforce, check, propagate, _local, dynamic, removable, stickingatnode) + 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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_CONS}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_CONS}), scip, cons, name, binvar, slackcons) + ccall( + (:SCIPcreateConsBasicSuperindicator, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + 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) + ccall( + (:SCIPgetBinaryVarSuperindicator, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPgetSlackConsSuperindicator(cons) - ccall((:SCIPgetSlackConsSuperindicator, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_CONS},), cons) + ccall( + (:SCIPgetSlackConsSuperindicator, libscip), + Ptr{SCIP_CONS}, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPtransformMinUC(scip, success) - ccall((:SCIPtransformMinUC, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cuint}), scip, success) + ccall( + (:SCIPtransformMinUC, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cuint}), + 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) + ccall( + (:SCIPdialogExecChangeMinUC, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPincludeConshdlrSymresack(scip) - ccall((:SCIPincludeConshdlrSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrSymresack, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPcreateSymbreakCons( + scip, + cons, + name, + perm, + vars, + nvars, + ismodelcons, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateSymbreakCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Cint}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + perm, + vars, + nvars, + ismodelcons, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsSymresack( + scip, + cons, + name, + perm, + vars, + nvars, + ismodelcons, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, +) + ccall( + (:SCIPcreateConsSymresack, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Cint}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + scip, + cons, + name, + perm, + vars, + nvars, + ismodelcons, + initial, + separate, + enforce, + check, + propagate, + _local, + modifiable, + dynamic, + removable, + stickingatnode, + ) +end + +function SCIPcreateConsBasicSymresack( + scip, + cons, + name, + perm, + vars, + nvars, + ismodelcons, +) + ccall( + (:SCIPcreateConsBasicSymresack, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Ptr{Cint}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cuint, + ), + scip, + cons, + name, + perm, + vars, + nvars, + ismodelcons, + ) end -function SCIPcreateSymbreakCons(scip, cons, name, perm, vars, nvars, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateSymbreakCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, perm, vars, nvars, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, + Ptr{Cchar}, + Ptr{SCIP_VAR}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Cdouble, + ), + scip, + cons, + name, + var, + vbdvar, + vbdcoef, + lhs, + rhs, + ) end -function SCIPcreateConsSymresack(scip, cons, name, perm, vars, nvars, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) - ccall((:SCIPcreateConsSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, perm, vars, nvars, ismodelcons, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +function SCIPgetLhsVarbound(scip, cons) + ccall( + (:SCIPgetLhsVarbound, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end -function SCIPcreateConsBasicSymresack(scip, cons, name, perm, vars, nvars, ismodelcons) - ccall((:SCIPcreateConsBasicSymresack, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint), scip, cons, name, perm, vars, nvars, ismodelcons) +function SCIPgetRhsVarbound(scip, cons) + ccall( + (:SCIPgetRhsVarbound, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end -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}}, Ptr{Cchar}, Ptr{SCIP_VAR}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), 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}}, Ptr{Cchar}, 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) +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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPgetRowVarbound, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPcreateRowVarbound(scip, cons) - ccall((:SCIPcreateRowVarbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) -end - -function SCIPcleanupConssVarbound(scip, onlychecked, infeasible, naddconss, ndelconss, nchgbds) - ccall((:SCIPcleanupConssVarbound, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, onlychecked, infeasible, naddconss, ndelconss, nchgbds) + ccall( + (:SCIPcreateRowVarbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) +end + +function SCIPcleanupConssVarbound( + scip, + onlychecked, + infeasible, + naddconss, + ndelconss, + nchgbds, +) + ccall( + (:SCIPcleanupConssVarbound, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), + scip, + onlychecked, + infeasible, + naddconss, + ndelconss, + nchgbds, + ) end 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}}, Ptr{Cchar}, Cuint, Cint, Ptr{Ptr{SCIP_VAR}}, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint), scip, cons, name, rhs, nvars, vars, initial, separate, enforce, check, propagate, _local, modifiable, dynamic, removable, stickingatnode) +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}}, + Ptr{Cchar}, + Cuint, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + ), + 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}}, Ptr{Cchar}, Cuint, Cint, Ptr{Ptr{SCIP_VAR}}), scip, cons, name, rhs, nvars, vars) + ccall( + (:SCIPcreateConsBasicXor, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cchar}, + Cuint, + 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) + 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) + 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) + ccall( + (:SCIPgetIntVarXor, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPgetRhsXor(scip, cons) - ccall((:SCIPgetRhsXor, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPgetRhsXor, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPincludeConshdlrComponents(scip) - ccall((:SCIPincludeConshdlrComponents, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConshdlrComponents, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeDispDefault(scip) @@ -15196,363 +45731,1575 @@ function SCIPincludeDispDefault(scip) end function SCIPdialogExecMenu(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecMenu, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecMenu, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecMenuLazy(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecMenuLazy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecMenuLazy, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecChangeAddCons(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecChangeAddCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecChangeAddCons, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecChangeBounds(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecChangeBounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecChangeFreetransproblem(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecChangeFreetransproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecChangeBounds, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecChangeFreetransproblem( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecChangeFreetransproblem, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecChangeObjSense(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecChangeObjSense, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecChangeObjSense, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecChecksol(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecChecksol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecChecksol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecCliquegraph(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecCliquegraph, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecCliquegraph, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayBenders(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayBenders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayBenders, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayBranching(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayBranching, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayBranching, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayCompression(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayCompression, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayCompression, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayConflict(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayConflict, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayConflict, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayConshdlrs(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayConshdlrs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayConshdlrs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayDisplaycols(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayDisplaycols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayDisplaycols, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayExprhdlrs(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayExprhdlrs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayExprhdlrs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayCutselectors(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayCutselectors, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayCutselectors, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayHeuristics(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayHeuristics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayHeuristics, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayIIS(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayIIS, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayIIS, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayMemory(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayMemory, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecDisplayNodeselectors(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayNodeselectors, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayMemory, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecDisplayNodeselectors( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecDisplayNodeselectors, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayNlpi(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayNlpi, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayNlpi, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayParameters(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayParameters, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayParameters, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayPresolvers(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayPresolvers, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayPresolvers, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayPricers(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayPricers, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayPricers, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayProblem(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayProblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayProblem, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayPropagators(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayPropagators, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayPropagators, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayReaders(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayReaders, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayReaders, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayRelaxators(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayRelaxators, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayRelaxators, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplaySeparators(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplaySeparators, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplaySeparators, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplaySolution(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplaySolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecDisplayFiniteSolution(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayFiniteSolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplaySolution, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecDisplayFiniteSolution( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecDisplayFiniteSolution, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayDualSolution(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayDualSolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayDualSolution, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplaySolutionPool(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplaySolutionPool, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplaySolutionPool, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplaySubproblem(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplaySubproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplaySubproblem, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplaySubSolution(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplaySubSolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplaySubSolution, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayStatistics(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayStatistics, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplaySymmetry(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplaySymmetry, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecDisplayReoptStatistics(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayReoptStatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplaySymmetry, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecDisplayReoptStatistics( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecDisplayReoptStatistics, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayTransproblem(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayTransproblem, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayTransproblem, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecDisplayValue(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayValue, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecDisplayVarbranchstatistics(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayVarbranchstatistics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecDisplayLPSolutionQuality(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayLPSolutionQuality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecDisplayTranssolution(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayTranssolution, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecDisplayValue, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecDisplayVarbranchstatistics( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecDisplayVarbranchstatistics, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecDisplayLPSolutionQuality( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecDisplayLPSolutionQuality, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecDisplayTranssolution( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecDisplayTranssolution, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecHelp(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecHelp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecHelp, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecFree(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecFree, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecFree, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecNewstart(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecNewstart, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecNewstart, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecTransform(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecTransform, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecTransform, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecOptimize(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecOptimize, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecOptimize, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecConcurrentOpt(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecConcurrentOpt, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecConcurrentOpt, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecPresolve(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecPresolve, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecPresolve, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecIIS(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecIIS, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecIIS, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecQuit(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecQuit, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecQuit, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecRead(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecRead, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecRead, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetDefault(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetDefault, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetLoad(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetLoad, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetLoad, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetSave(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetSave, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetSave, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetDiffsave(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetDiffsave, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetDiffsave, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetParam(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogDescSetParam(scip, dialog) - ccall((:SCIPdialogDescSetParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) + ccall( + (:SCIPdialogDescSetParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DIALOG}), + scip, + dialog, + ) end function SCIPdialogExecFixParam(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecFixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecFixParam, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogDescFixParam(scip, dialog) - ccall((:SCIPdialogDescFixParam, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}), scip, dialog) -end - -function SCIPdialogExecSetBranchingDirection(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetBranchingDirection, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetBranchingPriority(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetBranchingPriority, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetHeuristicsAggressive(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetHeuristicsAggressive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetHeuristicsDefault(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetHeuristicsDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogDescFixParam, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_DIALOG}), + scip, + dialog, + ) +end + +function SCIPdialogExecSetBranchingDirection( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetBranchingDirection, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetBranchingPriority( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetBranchingPriority, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetHeuristicsAggressive( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetHeuristicsAggressive, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetHeuristicsDefault( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetHeuristicsDefault, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetHeuristicsFast(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetHeuristicsFast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetHeuristicsFast, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetHeuristicsOff(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetHeuristicsOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetPresolvingAggressive(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetPresolvingAggressive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetPresolvingDefault(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetPresolvingDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetHeuristicsOff, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetPresolvingAggressive( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetPresolvingAggressive, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetPresolvingDefault( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetPresolvingDefault, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetPresolvingFast(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetPresolvingFast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetPresolvingFast, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetPresolvingOff(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetPresolvingOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetSeparatingAggressive(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetSeparatingAggressive, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetSeparatingDefault(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetSeparatingDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetPresolvingOff, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetSeparatingAggressive( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetSeparatingAggressive, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetSeparatingDefault( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetSeparatingDefault, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetSeparatingFast(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetSeparatingFast, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetSeparatingFast, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetSeparatingOff(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetSeparatingOff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetSeparatingOff, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetEmphasisCounter(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetEmphasisCounter, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetEmphasisCounter, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetEmphasisCpsolver(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetEmphasisCpsolver, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetEmphasisCpsolver, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetEmphasisEasycip(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetEmphasisEasycip, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetEmphasisFeasibility(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetEmphasisFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetEmphasisEasycip, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetEmphasisFeasibility( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetEmphasisFeasibility, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetEmphasisHardlp(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetEmphasisHardlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetEmphasisOptimality(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetEmphasisOptimality, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetEmphasisHardlp, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetEmphasisOptimality( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetEmphasisOptimality, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetEmphasisNumerics(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetEmphasisNumerics, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecSetEmphasisBenchmark(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetEmphasisBenchmark, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetEmphasisNumerics, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecSetEmphasisBenchmark( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecSetEmphasisBenchmark, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPdialogExecSetLimitsObjective(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecSetLimitsObjective, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) -end - -function SCIPdialogExecDisplayLinearConsClassification(scip, dialog, dialoghdlr, nextdialog) - ccall((:SCIPdialogExecDisplayLinearConsClassification, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGHDLR}, Ptr{Ptr{SCIP_DIALOG}}), scip, dialog, dialoghdlr, nextdialog) + ccall( + (:SCIPdialogExecSetLimitsObjective, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) +end + +function SCIPdialogExecDisplayLinearConsClassification( + scip, + dialog, + dialoghdlr, + nextdialog, +) + ccall( + (:SCIPdialogExecDisplayLinearConsClassification, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_DIALOG}, + Ptr{SCIP_DIALOGHDLR}, + Ptr{Ptr{SCIP_DIALOG}}, + ), + scip, + dialog, + dialoghdlr, + nextdialog, + ) end function SCIPcreateRootDialog(scip, root) - ccall((:SCIPcreateRootDialog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), scip, root) + ccall( + (:SCIPcreateRootDialog, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_DIALOG}}), + scip, + root, + ) end function SCIPincludeDialogDefaultBasic(scip) - ccall((:SCIPincludeDialogDefaultBasic, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeDialogDefaultBasic, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeDialogDefaultSet(scip) - ccall((:SCIPincludeDialogDefaultSet, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeDialogDefaultSet, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeDialogDefaultFix(scip) - ccall((:SCIPincludeDialogDefaultFix, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeDialogDefaultFix, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeEventHdlrEstim(scip) - ccall((:SCIPincludeEventHdlrEstim, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeEventHdlrEstim, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPgetTreesizeEstimation(scip) @@ -15560,19 +47307,50 @@ function SCIPgetTreesizeEstimation(scip) end function SCIPincludeEventHdlrSolvingphase(scip) - ccall((:SCIPincludeEventHdlrSolvingphase, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeEventHdlrSolvingphase, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeEventHdlrSofttimelimit(scip) - ccall((:SCIPincludeEventHdlrSofttimelimit, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeEventHdlrSofttimelimit, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPcreateExprAbs(scip, expr, child, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprAbs, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprAbs, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + child, + ownercreate, + ownercreatedata, + ) end function SCIPisExprAbs(scip, expr) - ccall((:SCIPisExprAbs, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprAbs, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPincludeExprhdlrAbs(scip) @@ -15580,23 +47358,70 @@ function SCIPincludeExprhdlrAbs(scip) end function SCIPincludeExprhdlrEntropy(scip) - ccall((:SCIPincludeExprhdlrEntropy, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeExprhdlrEntropy, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPcreateExprEntropy(scip, expr, child, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprEntropy, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprEntropy, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + child, + ownercreate, + ownercreatedata, + ) end function SCIPisExprEntropy(scip, expr) - ccall((:SCIPisExprEntropy, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprEntropy, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPcreateExprExp(scip, expr, child, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprExp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprExp, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + child, + ownercreate, + ownercreatedata, + ) end function SCIPisExprExp(scip, expr) - ccall((:SCIPisExprExp, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprExp, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPincludeExprhdlrExp(scip) @@ -15604,27 +47429,102 @@ function SCIPincludeExprhdlrExp(scip) end function SCIPcreateExprLog(scip, expr, child, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprLog, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprLog, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + child, + ownercreate, + ownercreatedata, + ) end function SCIPisExprLog(scip, expr) - ccall((:SCIPisExprLog, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprLog, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPincludeExprhdlrLog(scip) ccall((:SCIPincludeExprhdlrLog, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPcreateExprPow(scip, expr, child, exponent, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprPow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, exponent, ownercreate, ownercreatedata) -end - -function SCIPcreateExprSignpower(scip, expr, child, exponent, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprSignpower, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, exponent, ownercreate, ownercreatedata) +function SCIPcreateExprPow( + scip, + expr, + child, + exponent, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcreateExprPow, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Cdouble, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + child, + exponent, + ownercreate, + ownercreatedata, + ) +end + +function SCIPcreateExprSignpower( + scip, + expr, + child, + exponent, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcreateExprSignpower, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Cdouble, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + child, + exponent, + ownercreate, + ownercreatedata, + ) end function SCIPisExprSignpower(scip, expr) - ccall((:SCIPisExprSignpower, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprSignpower, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPincludeExprhdlrPow(scip) @@ -15632,55 +47532,286 @@ function SCIPincludeExprhdlrPow(scip) end function SCIPincludeExprhdlrSignpower(scip) - ccall((:SCIPincludeExprhdlrSignpower, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPaddSquareLinearization(scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) - ccall((:SCIPaddSquareLinearization, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), scip, sqrcoef, refpoint, isint, lincoef, linconstant, success) -end - -function SCIPaddSquareSecant(scip, sqrcoef, lb, ub, lincoef, linconstant, success) - ccall((:SCIPaddSquareSecant, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), scip, sqrcoef, lb, ub, lincoef, linconstant, success) -end - -function SCIPestimateRoot(scip, exponent, overestimate, xlb, xub, xref, constant, slope, islocal, success) - ccall((:SCIPestimateRoot, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cuint, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}), scip, exponent, overestimate, xlb, xub, xref, constant, slope, islocal, success) + ccall( + (:SCIPincludeExprhdlrSignpower, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPaddSquareLinearization( + scip, + sqrcoef, + refpoint, + isint, + lincoef, + linconstant, + success, +) + ccall( + (:SCIPaddSquareLinearization, libscip), + Cvoid, + ( + Ptr{SCIP}, + Cdouble, + Cdouble, + Cuint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + scip, + sqrcoef, + refpoint, + isint, + lincoef, + linconstant, + success, + ) +end + +function SCIPaddSquareSecant( + scip, + sqrcoef, + lb, + ub, + lincoef, + linconstant, + success, +) + ccall( + (:SCIPaddSquareSecant, libscip), + Cvoid, + ( + Ptr{SCIP}, + Cdouble, + Cdouble, + Cdouble, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + scip, + sqrcoef, + lb, + ub, + lincoef, + linconstant, + success, + ) +end + +function SCIPestimateRoot( + scip, + exponent, + overestimate, + xlb, + xub, + xref, + constant, + slope, + islocal, + success, +) + ccall( + (:SCIPestimateRoot, libscip), + Cvoid, + ( + Ptr{SCIP}, + Cdouble, + Cuint, + Cdouble, + Cdouble, + Cdouble, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + scip, + exponent, + overestimate, + xlb, + xub, + xref, + constant, + slope, + islocal, + success, + ) end function SCIPincludeExprhdlrProduct(scip) - ccall((:SCIPincludeExprhdlrProduct, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPcreateExprProduct(scip, expr, nchildren, children, coefficient, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprProduct, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Ptr{SCIP_EXPR}}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, nchildren, children, coefficient, ownercreate, ownercreatedata) + ccall( + (:SCIPincludeExprhdlrProduct, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPcreateExprProduct( + scip, + expr, + nchildren, + children, + coefficient, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcreateExprProduct, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Cint, + Ptr{Ptr{SCIP_EXPR}}, + Cdouble, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + nchildren, + children, + coefficient, + ownercreate, + ownercreatedata, + ) end function SCIPincludeExprhdlrSum(scip) ccall((:SCIPincludeExprhdlrSum, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPcreateExprSum(scip, expr, nchildren, children, coefficients, constant, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cdouble}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, nchildren, children, coefficients, constant, ownercreate, ownercreatedata) +function SCIPcreateExprSum( + scip, + expr, + nchildren, + children, + coefficients, + constant, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPcreateExprSum, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Cint, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cdouble}, + Cdouble, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + nchildren, + children, + coefficients, + constant, + ownercreate, + ownercreatedata, + ) end function SCIPsetConstantExprSum(expr, constant) - ccall((:SCIPsetConstantExprSum, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cdouble), expr, constant) + ccall( + (:SCIPsetConstantExprSum, libscip), + Cvoid, + (Ptr{SCIP_EXPR}, Cdouble), + expr, + constant, + ) end function SCIPappendExprSumExpr(scip, expr, child, childcoef) - ccall((:SCIPappendExprSumExpr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}, Cdouble), scip, expr, child, childcoef) + ccall( + (:SCIPappendExprSumExpr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}, Cdouble), + scip, + expr, + child, + childcoef, + ) end function SCIPmultiplyByConstantExprSum(expr, constant) - ccall((:SCIPmultiplyByConstantExprSum, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cdouble), expr, constant) -end - -function SCIPmultiplyBySumExprSum(scip, product, factor1, factor2, simplify, ownercreate, ownercreatedata) - ccall((:SCIPmultiplyBySumExprSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{SCIP_EXPR}, Cuint, Ptr{Cvoid}, Ptr{Cvoid}), scip, product, factor1, factor2, simplify, ownercreate, ownercreatedata) -end - -function SCIPpowerExprSum(scip, result, base, exponent, simplify, ownercreate, ownercreatedata) - ccall((:SCIPpowerExprSum, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Cint, Cuint, Ptr{Cvoid}, Ptr{Cvoid}), scip, result, base, exponent, simplify, ownercreate, ownercreatedata) + ccall( + (:SCIPmultiplyByConstantExprSum, libscip), + Cvoid, + (Ptr{SCIP_EXPR}, Cdouble), + expr, + constant, + ) +end + +function SCIPmultiplyBySumExprSum( + scip, + product, + factor1, + factor2, + simplify, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPmultiplyBySumExprSum, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Ptr{SCIP_EXPR}, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + product, + factor1, + factor2, + simplify, + ownercreate, + ownercreatedata, + ) +end + +function SCIPpowerExprSum( + scip, + result, + base, + exponent, + simplify, + ownercreate, + ownercreatedata, +) + ccall( + (:SCIPpowerExprSum, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Cint, + Cuint, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + result, + base, + exponent, + simplify, + ownercreate, + ownercreatedata, + ) end function SCIPincludeExprhdlrSin(scip) @@ -15692,27 +47823,83 @@ function SCIPincludeExprhdlrCos(scip) end function SCIPcreateExprSin(scip, expr, child, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprSin, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprSin, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + child, + ownercreate, + ownercreatedata, + ) end function SCIPcreateExprCos(scip, expr, child, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprCos, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_EXPR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, child, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprCos, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{SCIP_EXPR}, + Ptr{Cvoid}, + Ptr{Cvoid}, + ), + scip, + expr, + child, + ownercreate, + ownercreatedata, + ) end function SCIPisExprSin(scip, expr) - ccall((:SCIPisExprSin, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprSin, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPisExprCos(scip, expr) - ccall((:SCIPisExprCos, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprCos, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPincludeExprhdlrValue(scip) - ccall((:SCIPincludeExprhdlrValue, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeExprhdlrValue, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPcreateExprValue(scip, expr, value, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprValue, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, value, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprValue, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), + scip, + expr, + value, + ownercreate, + ownercreatedata, + ) end function SCIPincludeExprhdlrVar(scip) @@ -15720,15 +47907,34 @@ function SCIPincludeExprhdlrVar(scip) end function SCIPcreateExprVar(scip, expr, var, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_VAR}, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, var, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprVar, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Ptr{SCIP_VAR}, Ptr{Cvoid}, Ptr{Cvoid}), + scip, + expr, + var, + ownercreate, + ownercreatedata, + ) end function SCIPincludeHeurActconsdiving(scip) - ccall((:SCIPincludeHeurActconsdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurActconsdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurAdaptivediving(scip) - ccall((:SCIPincludeHeurAdaptivediving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurAdaptivediving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurBound(scip) @@ -15740,19 +47946,39 @@ function SCIPincludeHeurClique(scip) end function SCIPincludeHeurCoefdiving(scip) - ccall((:SCIPincludeHeurCoefdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurCoefdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurCompletesol(scip) - ccall((:SCIPincludeHeurCompletesol, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurCompletesol, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurConflictdiving(scip) - ccall((:SCIPincludeHeurConflictdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurConflictdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurCrossover(scip) - ccall((:SCIPincludeHeurCrossover, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurCrossover, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurDins(scip) @@ -15760,7 +47986,12 @@ function SCIPincludeHeurDins(scip) end function SCIPincludeHeurDistributiondiving(scip) - ccall((:SCIPincludeHeurDistributiondiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurDistributiondiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurDKS(scip) @@ -15776,11 +48007,24 @@ function SCIPincludeHeurDualval(scip) end function SCIPapplyHeurDualval(scip, heur, result, refpoint) - ccall((:SCIPapplyHeurDualval, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Ptr{SCIP_SOL}), scip, heur, result, refpoint) + ccall( + (:SCIPapplyHeurDualval, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Ptr{SCIP_SOL}), + scip, + heur, + result, + refpoint, + ) end function SCIPincludeHeurFarkasdiving(scip) - ccall((:SCIPincludeHeurFarkasdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurFarkasdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurFeaspump(scip) @@ -15788,11 +48032,21 @@ function SCIPincludeHeurFeaspump(scip) end function SCIPincludeHeurFixandinfer(scip) - ccall((:SCIPincludeHeurFixandinfer, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurFixandinfer, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurFracdiving(scip) - ccall((:SCIPincludeHeurFracdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurFracdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurGins(scip) @@ -15800,35 +48054,87 @@ function SCIPincludeHeurGins(scip) end function SCIPincludeHeurGuideddiving(scip) - ccall((:SCIPincludeHeurGuideddiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurGuideddiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurIndicator(scip) - ccall((:SCIPincludeHeurIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurIndicator, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPheurPassIndicator(scip, heur, nindconss, indconss, solcand, obj) - ccall((:SCIPheurPassIndicator, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Cint, Ptr{Ptr{SCIP_CONS}}, Ptr{Cuint}, Cdouble), scip, heur, nindconss, indconss, solcand, obj) + ccall( + (:SCIPheurPassIndicator, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_HEUR}, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Ptr{Cuint}, + Cdouble, + ), + scip, + heur, + nindconss, + indconss, + solcand, + obj, + ) end function SCIPincludeHeurIndicatordiving(scip) - ccall((:SCIPincludeHeurIndicatordiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurIndicatordiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurIntdiving(scip) - ccall((:SCIPincludeHeurIntdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurIntdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurIntshifting(scip) - ccall((:SCIPincludeHeurIntshifting, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurIntshifting, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurLinesearchdiving(scip) - ccall((:SCIPincludeHeurLinesearchdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurLinesearchdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurLocalbranching(scip) - ccall((:SCIPincludeHeurLocalbranching, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurLocalbranching, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurLocks(scip) @@ -15836,7 +48142,15 @@ function SCIPincludeHeurLocks(scip) end function SCIPapplyLockFixings(scip, heurdata, cutoff, allrowsfulfilled) - ccall((:SCIPapplyLockFixings, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEURDATA}, Ptr{Cuint}, Ptr{Cuint}), scip, heurdata, cutoff, allrowsfulfilled) + ccall( + (:SCIPapplyLockFixings, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEURDATA}, Ptr{Cuint}, Ptr{Cuint}), + scip, + heurdata, + cutoff, + allrowsfulfilled, + ) end function SCIPincludeHeurLpface(scip) @@ -15848,7 +48162,12 @@ function SCIPincludeHeurAlns(scip) end function SCIPincludeHeurMultistart(scip) - ccall((:SCIPincludeHeurMultistart, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurMultistart, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurMutation(scip) @@ -15860,11 +48179,21 @@ function SCIPincludeHeurMpec(scip) end function SCIPincludeHeurNlpdiving(scip) - ccall((:SCIPincludeHeurNlpdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurNlpdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurObjpscostdiving(scip) - ccall((:SCIPincludeHeurObjpscostdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurObjpscostdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurOctane(scip) @@ -15884,35 +48213,129 @@ function SCIPincludeHeurPADM(scip) end function SCIPincludeHeurPscostdiving(scip) - ccall((:SCIPincludeHeurPscostdiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurPscostdiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurProximity(scip) - ccall((:SCIPincludeHeurProximity, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPapplyProximity(scip, heur, result, minimprove, nnodes, nlpiters, nusednodes, nusedlpiters, freesubscip) - ccall((:SCIPapplyProximity, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cdouble, Clonglong, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}, Cuint), scip, heur, result, minimprove, nnodes, nlpiters, nusednodes, nusedlpiters, freesubscip) + ccall( + (:SCIPincludeHeurProximity, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPapplyProximity( + scip, + heur, + result, + minimprove, + nnodes, + nlpiters, + nusednodes, + nusedlpiters, + freesubscip, +) + ccall( + (:SCIPapplyProximity, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_HEUR}, + Ptr{SCIP_RESULT}, + Cdouble, + Clonglong, + Clonglong, + Ptr{Clonglong}, + Ptr{Clonglong}, + Cuint, + ), + scip, + heur, + result, + minimprove, + nnodes, + nlpiters, + nusednodes, + nusedlpiters, + freesubscip, + ) end function SCIPdeleteSubproblemProximity(scip) - ccall((:SCIPdeleteSubproblemProximity, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPdeleteSubproblemProximity, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurRandrounding(scip) - ccall((:SCIPincludeHeurRandrounding, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurRandrounding, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurRens(scip) ccall((:SCIPincludeHeurRens, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPapplyRens(scip, heur, result, minfixingrate, minimprove, maxnodes, nstallnodes, startsol, binarybounds, uselprows) - ccall((:SCIPapplyRens, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cdouble, Cdouble, Clonglong, Clonglong, Cchar, Cuint, Cuint), scip, heur, result, minfixingrate, minimprove, maxnodes, nstallnodes, startsol, binarybounds, uselprows) +function SCIPapplyRens( + scip, + heur, + result, + minfixingrate, + minimprove, + maxnodes, + nstallnodes, + startsol, + binarybounds, + uselprows, +) + ccall( + (:SCIPapplyRens, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_HEUR}, + Ptr{SCIP_RESULT}, + Cdouble, + Cdouble, + Clonglong, + Clonglong, + Cchar, + Cuint, + Cuint, + ), + scip, + heur, + result, + minfixingrate, + minimprove, + maxnodes, + nstallnodes, + startsol, + binarybounds, + uselprows, + ) end function SCIPincludeHeurReoptsols(scip) - ccall((:SCIPincludeHeurReoptsols, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurReoptsols, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPreoptsolsGetNCheckedsols(scip) @@ -15932,7 +48355,12 @@ function SCIPincludeHeurRins(scip) end function SCIPincludeHeurRootsoldiving(scip) - ccall((:SCIPincludeHeurRootsoldiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurRootsoldiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurRounding(scip) @@ -15940,11 +48368,21 @@ function SCIPincludeHeurRounding(scip) end function SCIPincludeHeurScheduler(scip) - ccall((:SCIPincludeHeurScheduler, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurScheduler, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurShiftandpropagate(scip) - ccall((:SCIPincludeHeurShiftandpropagate, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurShiftandpropagate, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurShifting(scip) @@ -15952,7 +48390,12 @@ function SCIPincludeHeurShifting(scip) end function SCIPincludeHeurSimplerounding(scip) - ccall((:SCIPincludeHeurSimplerounding, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurSimplerounding, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurSubNlp(scip) @@ -15960,15 +48403,44 @@ function SCIPincludeHeurSubNlp(scip) end function SCIPapplyHeurSubNlp(scip, heur, result, refpoint, resultsol) - ccall((:SCIPapplyHeurSubNlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Ptr{SCIP_SOL}, Ptr{SCIP_SOL}), scip, heur, result, refpoint, resultsol) + ccall( + (:SCIPapplyHeurSubNlp, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_HEUR}, + Ptr{SCIP_RESULT}, + Ptr{SCIP_SOL}, + Ptr{SCIP_SOL}, + ), + scip, + heur, + result, + refpoint, + resultsol, + ) end function SCIPupdateStartpointHeurSubNlp(scip, heur, solcand, violation) - ccall((:SCIPupdateStartpointHeurSubNlp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}, Cdouble), scip, heur, solcand, violation) + ccall( + (:SCIPupdateStartpointHeurSubNlp, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}, Cdouble), + scip, + heur, + solcand, + violation, + ) end function SCIPgetStartCandidateHeurSubNlp(scip, heur) - ccall((:SCIPgetStartCandidateHeurSubNlp, libscip), Ptr{SCIP_SOL}, (Ptr{SCIP}, Ptr{SCIP_HEUR}), scip, heur) + ccall( + (:SCIPgetStartCandidateHeurSubNlp, libscip), + Ptr{SCIP_SOL}, + (Ptr{SCIP}, Ptr{SCIP_HEUR}), + scip, + heur, + ) end function SCIPincludeHeurTrivial(scip) @@ -15976,11 +48448,21 @@ function SCIPincludeHeurTrivial(scip) end function SCIPincludeHeurTrivialnegation(scip) - ccall((:SCIPincludeHeurTrivialnegation, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurTrivialnegation, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurTrustregion(scip) - ccall((:SCIPincludeHeurTrustregion, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurTrustregion, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurTrySol(scip) @@ -15988,11 +48470,25 @@ function SCIPincludeHeurTrySol(scip) end function SCIPheurPassSolTrySol(scip, heur, sol) - ccall((:SCIPheurPassSolTrySol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}), scip, heur, sol) + ccall( + (:SCIPheurPassSolTrySol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}), + scip, + heur, + sol, + ) end function SCIPheurPassSolAddSol(scip, heur, sol) - ccall((:SCIPheurPassSolAddSol, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}), scip, heur, sol) + ccall( + (:SCIPheurPassSolAddSol, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_SOL}), + scip, + heur, + sol, + ) end function SCIPincludeHeurTwoopt(scip) @@ -16000,11 +48496,64 @@ function SCIPincludeHeurTwoopt(scip) end function SCIPincludeHeurUndercover(scip) - ccall((:SCIPincludeHeurUndercover, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPcomputeCoverUndercover(scip, coversize, cover, timelimit, memorylimit, objlimit, globalbounds, onlyconvexify, coverand, coverbd, coverind, covernl, coveringobj, success) - ccall((:SCIPcomputeCoverUndercover, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Cuint, Cuint, Cuint, Cuint, Cchar, Ptr{Cuint}), scip, coversize, cover, timelimit, memorylimit, objlimit, globalbounds, onlyconvexify, coverand, coverbd, coverind, covernl, coveringobj, success) + ccall( + (:SCIPincludeHeurUndercover, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPcomputeCoverUndercover( + scip, + coversize, + cover, + timelimit, + memorylimit, + objlimit, + globalbounds, + onlyconvexify, + coverand, + coverbd, + coverind, + covernl, + coveringobj, + success, +) + ccall( + (:SCIPcomputeCoverUndercover, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cint}, + Ptr{Ptr{SCIP_VAR}}, + Cdouble, + Cdouble, + Cdouble, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cuint, + Cchar, + Ptr{Cuint}, + ), + scip, + coversize, + cover, + timelimit, + memorylimit, + objlimit, + globalbounds, + onlyconvexify, + coverand, + coverbd, + coverind, + covernl, + coveringobj, + success, + ) end function SCIPincludeHeurVbounds(scip) @@ -16012,7 +48561,12 @@ function SCIPincludeHeurVbounds(scip) end function SCIPincludeHeurVeclendiving(scip) - ccall((:SCIPincludeHeurVeclendiving, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurVeclendiving, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeHeurZeroobj(scip) @@ -16020,51 +48574,304 @@ function SCIPincludeHeurZeroobj(scip) end function SCIPapplyZeroobj(scip, heur, result, minimprove, nnodes) - ccall((:SCIPapplyZeroobj, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cdouble, Clonglong), scip, heur, result, minimprove, nnodes) + ccall( + (:SCIPapplyZeroobj, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_HEUR}, Ptr{SCIP_RESULT}, Cdouble, Clonglong), + scip, + heur, + result, + minimprove, + nnodes, + ) end function SCIPincludeHeurZirounding(scip) - ccall((:SCIPincludeHeurZirounding, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeHeurZirounding, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeIISfinderGreedy(scip) - ccall((:SCIPincludeIISfinderGreedy, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeIISfinderGreedy, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPiisGreedyMakeIrreducible(iis) - ccall((:SCIPiisGreedyMakeIrreducible, libscip), SCIP_RETCODE, (Ptr{SCIP_IIS},), iis) + ccall( + (:SCIPiisGreedyMakeIrreducible, libscip), + SCIP_RETCODE, + (Ptr{SCIP_IIS},), + iis, + ) end function SCIPincludeNlhdlrBilinear(scip) - ccall((:SCIPincludeNlhdlrBilinear, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlhdlrBilinear, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPgetExprsBilinear(nlhdlr) - ccall((:SCIPgetExprsBilinear, libscip), Ptr{Ptr{SCIP_EXPR}}, (Ptr{SCIP_NLHDLR},), nlhdlr) + ccall( + (:SCIPgetExprsBilinear, libscip), + Ptr{Ptr{SCIP_EXPR}}, + (Ptr{SCIP_NLHDLR},), + nlhdlr, + ) end function SCIPgetNExprsBilinear(nlhdlr) ccall((:SCIPgetNExprsBilinear, libscip), Cint, (Ptr{SCIP_NLHDLR},), nlhdlr) end -function SCIPaddIneqBilinear(scip, nlhdlr, expr, xcoef, ycoef, constant, success) - ccall((:SCIPaddIneqBilinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_NLHDLR}, Ptr{SCIP_EXPR}, Cdouble, Cdouble, Cdouble, Ptr{Cuint}), scip, nlhdlr, expr, xcoef, ycoef, constant, 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{Cuint}), 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, Cuint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), 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, Cuint, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), 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, xcoef1, ycoef1, constant1, xcoef2, ycoef2, constant2, lincoefx, lincoefy, linconstant, success) - ccall((:SCIPcomputeBilinEnvelope2, libscip), Cvoid, (Ptr{SCIP}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cuint, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), scip, bilincoef, lbx, ubx, refpointx, lby, uby, refpointy, overestimate, xcoef1, ycoef1, constant1, xcoef2, ycoef2, constant2, lincoefx, lincoefy, linconstant, success) +function SCIPaddIneqBilinear( + scip, + nlhdlr, + expr, + xcoef, + ycoef, + constant, + success, +) + ccall( + (:SCIPaddIneqBilinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_NLHDLR}, + Ptr{SCIP_EXPR}, + Cdouble, + Cdouble, + Cdouble, + Ptr{Cuint}, + ), + scip, + nlhdlr, + expr, + xcoef, + ycoef, + constant, + 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{Cuint}, + ), + 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, + Cuint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + 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, + Cuint, + Cdouble, + Cdouble, + Cdouble, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + 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, + xcoef1, + ycoef1, + constant1, + xcoef2, + ycoef2, + constant2, + lincoefx, + lincoefy, + linconstant, + success, +) + ccall( + (:SCIPcomputeBilinEnvelope2, libscip), + Cvoid, + ( + Ptr{SCIP}, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cuint, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + scip, + bilincoef, + lbx, + ubx, + refpointx, + lby, + uby, + refpointy, + overestimate, + xcoef1, + ycoef1, + constant1, + xcoef2, + ycoef2, + constant2, + lincoefx, + lincoefy, + linconstant, + success, + ) end function SCIPincludeNlhdlrConvex(scip) @@ -16072,43 +48879,160 @@ function SCIPincludeNlhdlrConvex(scip) end function SCIPincludeNlhdlrConcave(scip) - ccall((:SCIPincludeNlhdlrConcave, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlhdlrConcave, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPhasExprCurvature(scip, expr, curv, success, assumevarfixed) - ccall((:SCIPhasExprCurvature, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_EXPR}, SCIP_EXPRCURV, Ptr{Cuint}, Ptr{SCIP_HASHMAP}), scip, expr, curv, success, assumevarfixed) + ccall( + (:SCIPhasExprCurvature, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_EXPR}, + SCIP_EXPRCURV, + Ptr{Cuint}, + Ptr{SCIP_HASHMAP}, + ), + scip, + expr, + curv, + success, + assumevarfixed, + ) end function SCIPincludeNlhdlrDefault(scip) - ccall((:SCIPincludeNlhdlrDefault, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlhdlrDefault, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeNlhdlrPerspective(scip) - ccall((:SCIPincludeNlhdlrPerspective, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlhdlrPerspective, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeNlhdlrQuadratic(scip) - ccall((:SCIPincludeNlhdlrQuadratic, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlhdlrQuadratic, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeNlhdlrQuotient(scip) - ccall((:SCIPincludeNlhdlrQuotient, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlhdlrQuotient, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeNlhdlrSignomial(scip) - ccall((:SCIPincludeNlhdlrSignomial, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlhdlrSignomial, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeNlhdlrSoc(scip) ccall((:SCIPincludeNlhdlrSoc, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPisSOCNonlinear(scip, cons, compeigenvalues, success, sidetype, vars, offsets, transcoefs, transcoefsidx, termbegins, nvars, nterms) - ccall((:SCIPisSOCNonlinear, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Cuint, Ptr{Cuint}, Ptr{SCIP_SIDETYPE}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}), scip, cons, compeigenvalues, success, sidetype, vars, offsets, transcoefs, transcoefsidx, termbegins, nvars, nterms) -end - -function SCIPfreeSOCArraysNonlinear(scip, vars, offsets, transcoefs, transcoefsidx, termbegins, nvars, nterms) - ccall((:SCIPfreeSOCArraysNonlinear, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Cint, Cint), scip, vars, offsets, transcoefs, transcoefsidx, termbegins, nvars, nterms) +function SCIPisSOCNonlinear( + scip, + cons, + compeigenvalues, + success, + sidetype, + vars, + offsets, + transcoefs, + transcoefsidx, + termbegins, + nvars, + nterms, +) + ccall( + (:SCIPisSOCNonlinear, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_CONS}, + Cuint, + Ptr{Cuint}, + Ptr{SCIP_SIDETYPE}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + cons, + compeigenvalues, + success, + sidetype, + vars, + offsets, + transcoefs, + transcoefsidx, + termbegins, + nvars, + nterms, + ) +end + +function SCIPfreeSOCArraysNonlinear( + scip, + vars, + offsets, + transcoefs, + transcoefsidx, + termbegins, + nvars, + nterms, +) + ccall( + (:SCIPfreeSOCArraysNonlinear, libscip), + Cvoid, + ( + Ptr{SCIP}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cint}}, + Cint, + Cint, + ), + scip, + vars, + offsets, + transcoefs, + transcoefsidx, + termbegins, + nvars, + nterms, + ) end function SCIPincludeNodeselBfs(scip) @@ -16116,7 +49040,12 @@ function SCIPincludeNodeselBfs(scip) end function SCIPincludeNodeselBreadthfirst(scip) - ccall((:SCIPincludeNodeselBreadthfirst, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNodeselBreadthfirst, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeNodeselDfs(scip) @@ -16124,11 +49053,21 @@ function SCIPincludeNodeselDfs(scip) end function SCIPincludeNodeselEstimate(scip) - ccall((:SCIPincludeNodeselEstimate, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNodeselEstimate, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeNodeselHybridestim(scip) - ccall((:SCIPincludeNodeselHybridestim, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNodeselHybridestim, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeNodeselUct(scip) @@ -16136,15 +49075,30 @@ function SCIPincludeNodeselUct(scip) end function SCIPincludeNodeselRestartdfs(scip) - ccall((:SCIPincludeNodeselRestartdfs, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNodeselRestartdfs, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolBoundshift(scip) - ccall((:SCIPincludePresolBoundshift, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolBoundshift, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolConvertinttobin(scip) - ccall((:SCIPincludePresolConvertinttobin, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolConvertinttobin, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolDomcol(scip) @@ -16152,31 +49106,66 @@ function SCIPincludePresolDomcol(scip) end function SCIPincludePresolDualagg(scip) - ccall((:SCIPincludePresolDualagg, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolDualagg, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolDualcomp(scip) - ccall((:SCIPincludePresolDualcomp, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolDualcomp, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolDualinfer(scip) - ccall((:SCIPincludePresolDualinfer, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolDualinfer, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolGateextraction(scip) - ccall((:SCIPincludePresolGateextraction, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolGateextraction, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolImplics(scip) - ccall((:SCIPincludePresolImplics, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolImplics, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolImplint(scip) - ccall((:SCIPincludePresolImplint, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolImplint, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolInttobinary(scip) - ccall((:SCIPincludePresolInttobinary, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolInttobinary, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolMILP(scip) @@ -16188,39 +49177,107 @@ function SCIPincludePresolRedvub(scip) end function SCIPincludePresolQPKKTref(scip) - ccall((:SCIPincludePresolQPKKTref, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolQPKKTref, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolTrivial(scip) - ccall((:SCIPincludePresolTrivial, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolTrivial, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolTworowbnd(scip) - ccall((:SCIPincludePresolTworowbnd, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolTworowbnd, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolSparsify(scip) - ccall((:SCIPincludePresolSparsify, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolSparsify, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolDualsparsify(scip) - ccall((:SCIPincludePresolDualsparsify, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolDualsparsify, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePresolStuffing(scip) - ccall((:SCIPincludePresolStuffing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePresolStuffing, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePropDualfix(scip) ccall((:SCIPincludePropDualfix, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPgenVBoundAdd(scip, genvboundprop, vars, var, coefs, ncoefs, coefcutoffbound, constant, boundtype) - ccall((:SCIPgenVBoundAdd, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_VAR}, Ptr{Cdouble}, Cint, Cdouble, Cdouble, SCIP_BOUNDTYPE), scip, genvboundprop, vars, var, coefs, ncoefs, coefcutoffbound, constant, boundtype) +function SCIPgenVBoundAdd( + scip, + genvboundprop, + vars, + var, + coefs, + ncoefs, + coefcutoffbound, + constant, + boundtype, +) + ccall( + (:SCIPgenVBoundAdd, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_PROP}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{SCIP_VAR}, + Ptr{Cdouble}, + Cint, + Cdouble, + Cdouble, + SCIP_BOUNDTYPE, + ), + scip, + genvboundprop, + vars, + var, + coefs, + ncoefs, + coefcutoffbound, + constant, + boundtype, + ) end function SCIPincludePropGenvbounds(scip) - ccall((:SCIPincludePropGenvbounds, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePropGenvbounds, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePropNlobbt(scip) @@ -16235,20 +49292,154 @@ function SCIPincludePropProbing(scip) ccall((:SCIPincludePropProbing, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPapplyProbingVar(scip, vars, nvars, probingpos, boundtype, bound, maxproprounds, impllbs, implubs, proplbs, propubs, cutoff) - ccall((:SCIPapplyProbingVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, SCIP_BOUNDTYPE, Cdouble, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), scip, vars, nvars, probingpos, boundtype, bound, maxproprounds, impllbs, implubs, proplbs, propubs, cutoff) -end - -function SCIPanalyzeDeductionsProbing(scip, probingvar, leftub, rightlb, nvars, vars, leftimpllbs, leftimplubs, leftproplbs, leftpropubs, rightimpllbs, rightimplubs, rightproplbs, rightpropubs, nfixedvars, naggrvars, nimplications, nchgbds, cutoff) - ccall((:SCIPanalyzeDeductionsProbing, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}), scip, probingvar, leftub, rightlb, nvars, vars, leftimpllbs, leftimplubs, leftproplbs, leftpropubs, rightimpllbs, rightimplubs, rightproplbs, rightpropubs, nfixedvars, naggrvars, nimplications, nchgbds, cutoff) +function SCIPapplyProbingVar( + scip, + vars, + nvars, + probingpos, + boundtype, + bound, + maxproprounds, + impllbs, + implubs, + proplbs, + propubs, + cutoff, +) + ccall( + (:SCIPapplyProbingVar, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cint, + SCIP_BOUNDTYPE, + Cdouble, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + scip, + vars, + nvars, + probingpos, + boundtype, + bound, + maxproprounds, + impllbs, + implubs, + proplbs, + propubs, + cutoff, + ) +end + +function SCIPanalyzeDeductionsProbing( + scip, + probingvar, + leftub, + rightlb, + nvars, + vars, + leftimpllbs, + leftimplubs, + leftproplbs, + leftpropubs, + rightimpllbs, + rightimplubs, + rightproplbs, + rightpropubs, + nfixedvars, + naggrvars, + nimplications, + nchgbds, + cutoff, +) + ccall( + (:SCIPanalyzeDeductionsProbing, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cuint}, + ), + scip, + probingvar, + leftub, + rightlb, + nvars, + vars, + leftimpllbs, + leftimplubs, + leftproplbs, + leftpropubs, + rightimpllbs, + rightimplubs, + rightproplbs, + rightpropubs, + nfixedvars, + naggrvars, + nimplications, + nchgbds, + cutoff, + ) end function SCIPincludePropPseudoobj(scip) - ccall((:SCIPincludePropPseudoobj, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPpropagateCutoffboundVar(scip, prop, var, cutoffbound, pseudoobjval, tightened) - ccall((:SCIPpropagateCutoffboundVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}, Ptr{SCIP_VAR}, Cdouble, Cdouble, Ptr{Cuint}), scip, prop, var, cutoffbound, pseudoobjval, tightened) + ccall( + (:SCIPincludePropPseudoobj, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPpropagateCutoffboundVar( + scip, + prop, + var, + cutoffbound, + pseudoobjval, + tightened, +) + ccall( + (:SCIPpropagateCutoffboundVar, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_PROP}, + Ptr{SCIP_VAR}, + Cdouble, + Cdouble, + Ptr{Cuint}, + ), + scip, + prop, + var, + cutoffbound, + pseudoobjval, + tightened, + ) end function SCIPincludePropRedcost(scip) @@ -16256,15 +49447,65 @@ function SCIPincludePropRedcost(scip) end function SCIPincludePropRootredcost(scip) - ccall((:SCIPincludePropRootredcost, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludePropRootredcost, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludePropSymmetry(scip) ccall((:SCIPincludePropSymmetry, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPgetSymmetry(scip, npermvars, permvars, permvarmap, nperms, perms, permstrans, log10groupsize, binvaraffected, components, componentbegins, vartocomponent, ncomponents) - ccall((:SCIPgetSymmetry, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cint}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{SCIP_HASHMAP}}, Ptr{Cint}, Ptr{Ptr{Ptr{Cint}}}, Ptr{Ptr{Ptr{Cint}}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Cint}), scip, npermvars, permvars, permvarmap, nperms, perms, permstrans, log10groupsize, binvaraffected, components, componentbegins, vartocomponent, ncomponents) +function SCIPgetSymmetry( + scip, + npermvars, + permvars, + permvarmap, + nperms, + perms, + permstrans, + log10groupsize, + binvaraffected, + components, + componentbegins, + vartocomponent, + ncomponents, +) + ccall( + (:SCIPgetSymmetry, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Cint}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Ptr{SCIP_HASHMAP}}, + Ptr{Cint}, + Ptr{Ptr{Ptr{Cint}}}, + Ptr{Ptr{Ptr{Cint}}}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + ), + scip, + npermvars, + permvars, + permvarmap, + nperms, + perms, + permstrans, + log10groupsize, + binvaraffected, + components, + componentbegins, + vartocomponent, + ncomponents, + ) end function SCIPgetSymmetryNGenerators(scip) @@ -16272,15 +49513,35 @@ function SCIPgetSymmetryNGenerators(scip) end function SCIPdisplaySymmetryGenerators(scip, prop) - ccall((:SCIPdisplaySymmetryGenerators, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_PROP}), scip, prop) + ccall( + (:SCIPdisplaySymmetryGenerators, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_PROP}), + scip, + prop, + ) end function SCIPcreateSymOpNodeType(scip, opnodename, nodetype) - ccall((:SCIPcreateSymOpNodeType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), scip, opnodename, nodetype) + ccall( + (:SCIPcreateSymOpNodeType, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), + scip, + opnodename, + nodetype, + ) end function SCIPgetSymOpNodeType(scip, opnodename, nodetype) - ccall((:SCIPgetSymOpNodeType, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), scip, opnodename, nodetype) + ccall( + (:SCIPgetSymOpNodeType, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{Cint}), + scip, + opnodename, + nodetype, + ) end function SCIPincludePropVbounds(scip) @@ -16292,7 +49553,14 @@ function SCIPisPropagatedVbounds(scip) end function SCIPexecPropVbounds(scip, force, result) - ccall((:SCIPexecPropVbounds, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{SCIP_RESULT}), scip, force, result) + ccall( + (:SCIPexecPropVbounds, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint, Ptr{SCIP_RESULT}), + scip, + force, + result, + ) end function SCIPincludeReaderBnd(scip) @@ -16303,8 +49571,41 @@ function SCIPincludeReaderCcg(scip) ccall((:SCIPincludeReaderCcg, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPwriteCcg(scip, file, name, transformed, vars, nvars, conss, nconss, result) - ccall((:SCIPwriteCcg, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, transformed, vars, nvars, conss, nconss, result) +function SCIPwriteCcg( + scip, + file, + name, + transformed, + vars, + nvars, + conss, + nconss, + result, +) + ccall( + (:SCIPwriteCcg, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Cchar}, + Cuint, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cint, + Ptr{SCIP_RESULT}, + ), + scip, + file, + name, + transformed, + vars, + nvars, + conss, + nconss, + result, + ) end function SCIPincludeReaderCip(scip) @@ -16320,7 +49621,14 @@ function SCIPincludeReaderCor(scip) end function SCIPreadCor(scip, filename, result) - ccall((:SCIPreadCor, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, filename, result) + ccall( + (:SCIPreadCor, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), + scip, + filename, + result, + ) end function SCIPfreeReaderdataCor(scip) @@ -16340,11 +49648,23 @@ function SCIPcorGetNConsNames(reader) end function SCIPcorGetVarName(reader, i) - ccall((:SCIPcorGetVarName, libscip), Ptr{Cchar}, (Ptr{SCIP_READER}, Cint), reader, i) + ccall( + (:SCIPcorGetVarName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_READER}, Cint), + reader, + i, + ) end function SCIPcorGetConsName(reader, i) - ccall((:SCIPcorGetConsName, libscip), Ptr{Cchar}, (Ptr{SCIP_READER}, Cint), reader, i) + ccall( + (:SCIPcorGetConsName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_READER}, Cint), + reader, + i, + ) end function SCIPincludeReaderDec(scip) @@ -16356,7 +49676,15 @@ function SCIPincludeReaderDiff(scip) end function SCIPreadDiff(scip, reader, filename, result) - ccall((:SCIPreadDiff, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, reader, filename, result) + ccall( + (:SCIPreadDiff, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), + scip, + reader, + filename, + result, + ) end function SCIPincludeReaderFix(scip) @@ -16368,15 +49696,76 @@ function SCIPincludeReaderFzn(scip) end function SCIPprintSolReaderFzn(scip, sol, file) - ccall((:SCIPprintSolReaderFzn, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), scip, sol, file) + ccall( + (:SCIPprintSolReaderFzn, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), + scip, + sol, + file, + ) end function SCIPincludeReaderGms(scip) ccall((:SCIPincludeReaderGms, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPwriteGms(scip, file, name, transformed, objsense, objscale, objoffset, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) - ccall((:SCIPwriteGms, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, transformed, objsense, objscale, objoffset, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) +function SCIPwriteGms( + scip, + file, + name, + transformed, + objsense, + objscale, + objoffset, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + conss, + nconss, + result, +) + ccall( + (:SCIPwriteGms, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Cchar}, + Cuint, + SCIP_OBJSENSE, + Cdouble, + Cdouble, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cint, + Cint, + Cint, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cint, + Ptr{SCIP_RESULT}, + ), + scip, + file, + name, + transformed, + objsense, + objscale, + objoffset, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + conss, + nconss, + result, + ) end function SCIPincludeReaderLp(scip) @@ -16384,23 +49773,196 @@ function SCIPincludeReaderLp(scip) end function SCIPreadLp(scip, reader, filename, result) - ccall((:SCIPreadLp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, reader, filename, result) -end - -function SCIPwriteLp(scip, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) - ccall((:SCIPwriteLp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) + ccall( + (:SCIPreadLp, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), + scip, + reader, + filename, + result, + ) +end + +function SCIPwriteLp( + scip, + file, + name, + transformed, + objsense, + objoffset, + objscale, + objoffsetexact, + objscaleexact, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + conss, + nconss, + result, +) + ccall( + (:SCIPwriteLp, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Cchar}, + Cuint, + SCIP_OBJSENSE, + Cdouble, + Cdouble, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cint, + Cint, + Cint, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cint, + Ptr{SCIP_RESULT}, + ), + scip, + file, + name, + transformed, + objsense, + objoffset, + objscale, + objoffsetexact, + objscaleexact, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + conss, + nconss, + result, + ) end function SCIPincludeReaderMps(scip) ccall((:SCIPincludeReaderMps, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPreadMps(scip, reader, filename, result, varnames, consnames, varnamessize, consnamessize, nvarnames, nconsnames) - ccall((:SCIPreadMps, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}, Ptr{Ptr{Ptr{Cchar}}}, Ptr{Ptr{Ptr{Cchar}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, reader, filename, result, varnames, consnames, varnamessize, consnamessize, nvarnames, nconsnames) -end - -function SCIPwriteMps(scip, reader, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, result) - ccall((:SCIPwriteMps, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, reader, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, result) +function SCIPreadMps( + scip, + reader, + filename, + result, + varnames, + consnames, + varnamessize, + consnamessize, + nvarnames, + nconsnames, +) + ccall( + (:SCIPreadMps, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_READER}, + Ptr{Cchar}, + Ptr{SCIP_RESULT}, + Ptr{Ptr{Ptr{Cchar}}}, + Ptr{Ptr{Ptr{Cchar}}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + reader, + filename, + result, + varnames, + consnames, + varnamessize, + consnamessize, + nvarnames, + nconsnames, + ) +end + +function SCIPwriteMps( + scip, + reader, + file, + name, + transformed, + objsense, + objoffset, + objscale, + objoffsetexact, + objscaleexact, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + fixedvars, + nfixedvars, + conss, + nconss, + result, +) + ccall( + (:SCIPwriteMps, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_READER}, + Ptr{Libc.FILE}, + Ptr{Cchar}, + Cuint, + SCIP_OBJSENSE, + Cdouble, + Cdouble, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cint, + Cint, + Cint, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cint, + Ptr{SCIP_RESULT}, + ), + scip, + reader, + file, + name, + transformed, + objsense, + objoffset, + objscale, + objoffsetexact, + objscaleexact, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + fixedvars, + nfixedvars, + conss, + nconss, + result, + ) end function SCIPincludeReaderMst(scip) @@ -16420,11 +49982,88 @@ function SCIPincludeReaderOpb(scip) end function SCIPreadOpb(scip, reader, filename, result) - ccall((:SCIPreadOpb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, reader, filename, result) -end - -function SCIPwriteOpb(scip, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, genericnames, result) - ccall((:SCIPwriteOpb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Cuint, Ptr{SCIP_RESULT}), scip, file, name, transformed, objsense, objoffset, objscale, objoffsetexact, objscaleexact, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, conss, nconss, genericnames, result) + ccall( + (:SCIPreadOpb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), + scip, + reader, + filename, + result, + ) +end + +function SCIPwriteOpb( + scip, + file, + name, + transformed, + objsense, + objoffset, + objscale, + objoffsetexact, + objscaleexact, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + fixedvars, + nfixedvars, + conss, + nconss, + genericnames, + result, +) + ccall( + (:SCIPwriteOpb, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Cchar}, + Cuint, + SCIP_OBJSENSE, + Cdouble, + Cdouble, + Ptr{SCIP_RATIONAL}, + Ptr{SCIP_RATIONAL}, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cint, + Cint, + Cint, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cint, + Cuint, + Ptr{SCIP_RESULT}, + ), + scip, + file, + name, + transformed, + objsense, + objoffset, + objscale, + objoffsetexact, + objscaleexact, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + fixedvars, + nfixedvars, + conss, + nconss, + genericnames, + result, + ) end function SCIPincludeReaderOsil(scip) @@ -16436,27 +50075,158 @@ function SCIPincludeReaderPip(scip) end function SCIPreadPip(scip, reader, filename, result) - ccall((:SCIPreadPip, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, reader, filename, result) -end - -function SCIPwritePip(scip, file, name, transformed, objsense, objscale, objoffset, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) - ccall((:SCIPwritePip, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Cuint, SCIP_OBJSENSE, Cdouble, Cdouble, Ptr{Ptr{SCIP_VAR}}, Cint, Cint, Cint, Cint, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, transformed, objsense, objscale, objoffset, vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) + ccall( + (:SCIPreadPip, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_READER}, Ptr{Cchar}, Ptr{SCIP_RESULT}), + scip, + reader, + filename, + result, + ) +end + +function SCIPwritePip( + scip, + file, + name, + transformed, + objsense, + objscale, + objoffset, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + conss, + nconss, + result, +) + ccall( + (:SCIPwritePip, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Cchar}, + Cuint, + SCIP_OBJSENSE, + Cdouble, + Cdouble, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cint, + Cint, + Cint, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cint, + Ptr{SCIP_RESULT}, + ), + scip, + file, + name, + transformed, + objsense, + objscale, + objoffset, + vars, + nvars, + nbinvars, + nintvars, + nimplvars, + ncontvars, + conss, + nconss, + result, + ) end function SCIPincludeReaderPpm(scip) ccall((:SCIPincludeReaderPpm, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPwritePpm(scip, file, name, readerdata, transformed, vars, nvars, conss, nconss, result) - ccall((:SCIPwritePpm, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Ptr{SCIP_READERDATA}, Cuint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, readerdata, transformed, vars, nvars, conss, nconss, result) +function SCIPwritePpm( + scip, + file, + name, + readerdata, + transformed, + vars, + nvars, + conss, + nconss, + result, +) + ccall( + (:SCIPwritePpm, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Cchar}, + Ptr{SCIP_READERDATA}, + Cuint, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cint, + Ptr{SCIP_RESULT}, + ), + scip, + file, + name, + readerdata, + transformed, + vars, + nvars, + conss, + nconss, + result, + ) end function SCIPincludeReaderPbm(scip) ccall((:SCIPincludeReaderPbm, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPwritePbm(scip, file, name, readerdata, transformed, nvars, conss, nconss, result) - ccall((:SCIPwritePbm, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{Cchar}, Ptr{SCIP_READERDATA}, Cuint, Cint, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_RESULT}), scip, file, name, readerdata, transformed, nvars, conss, nconss, result) +function SCIPwritePbm( + scip, + file, + name, + readerdata, + transformed, + nvars, + conss, + nconss, + result, +) + ccall( + (:SCIPwritePbm, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Libc.FILE}, + Ptr{Cchar}, + Ptr{SCIP_READERDATA}, + Cuint, + Cint, + Ptr{Ptr{SCIP_CONS}}, + Cint, + Ptr{SCIP_RESULT}, + ), + scip, + file, + name, + readerdata, + transformed, + nvars, + conss, + nconss, + result, + ) end function SCIPincludeReaderRlp(scip) @@ -16476,7 +50246,14 @@ function SCIPincludeReaderSto(scip) end function SCIPreadSto(scip, filename, result) - ccall((:SCIPreadSto, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, filename, result) + ccall( + (:SCIPreadSto, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), + scip, + filename, + result, + ) end function SCIPstoGetNScenarios(scip) @@ -16492,7 +50269,14 @@ function SCIPincludeReaderTim(scip) end function SCIPreadTim(scip, filename, result) - ccall((:SCIPreadTim, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), scip, filename, result) + ccall( + (:SCIPreadTim, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Cchar}, Ptr{SCIP_RESULT}), + scip, + filename, + result, + ) end function SCIPfreeReaderdataTim(scip) @@ -16508,31 +50292,73 @@ function SCIPtimGetNStages(scip) end function SCIPtimGetStageName(scip, stagenum) - ccall((:SCIPtimGetStageName, libscip), Ptr{Cchar}, (Ptr{SCIP}, Cint), scip, stagenum) + ccall( + (:SCIPtimGetStageName, libscip), + Ptr{Cchar}, + (Ptr{SCIP}, Cint), + scip, + stagenum, + ) end function SCIPtimConsGetStageName(scip, consname) - ccall((:SCIPtimConsGetStageName, libscip), Ptr{Cchar}, (Ptr{SCIP}, Ptr{Cchar}), scip, consname) + ccall( + (:SCIPtimConsGetStageName, libscip), + Ptr{Cchar}, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + consname, + ) end function SCIPtimFindStage(scip, stage) - ccall((:SCIPtimFindStage, libscip), Cint, (Ptr{SCIP}, Ptr{Cchar}), scip, stage) + ccall( + (:SCIPtimFindStage, libscip), + Cint, + (Ptr{SCIP}, Ptr{Cchar}), + scip, + stage, + ) end function SCIPtimGetStageVars(scip, stagenum) - ccall((:SCIPtimGetStageVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP}, Cint), scip, stagenum) + ccall( + (:SCIPtimGetStageVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP}, Cint), + scip, + stagenum, + ) end function SCIPtimGetStageConss(scip, stagenum) - ccall((:SCIPtimGetStageConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP}, Cint), scip, stagenum) + ccall( + (:SCIPtimGetStageConss, libscip), + Ptr{Ptr{SCIP_CONS}}, + (Ptr{SCIP}, Cint), + scip, + stagenum, + ) end function SCIPtimGetStageNVars(scip, stagenum) - ccall((:SCIPtimGetStageNVars, libscip), Cint, (Ptr{SCIP}, Cint), scip, stagenum) + ccall( + (:SCIPtimGetStageNVars, libscip), + Cint, + (Ptr{SCIP}, Cint), + scip, + stagenum, + ) end function SCIPtimGetStageNConss(scip, stagenum) - ccall((:SCIPtimGetStageNConss, libscip), Cint, (Ptr{SCIP}, Cint), scip, stagenum) + ccall( + (:SCIPtimGetStageNConss, libscip), + Cint, + (Ptr{SCIP}, Cint), + scip, + stagenum, + ) end function SCIPincludeReaderWbo(scip) @@ -16556,23 +50382,49 @@ function SCIPincludeSepaClique(scip) end function SCIPincludeSepaClosecuts(scip) - ccall((:SCIPincludeSepaClosecuts, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeSepaClosecuts, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPsetBasePointClosecuts(scip, sol) - ccall((:SCIPsetBasePointClosecuts, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_SOL}), scip, sol) + ccall( + (:SCIPsetBasePointClosecuts, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_SOL}), + scip, + sol, + ) end function SCIPincludeSepaAggregation(scip) - ccall((:SCIPincludeSepaAggregation, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeSepaAggregation, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeSepaConvexproj(scip) - ccall((:SCIPincludeSepaConvexproj, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeSepaConvexproj, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeSepaDisjunctive(scip) - ccall((:SCIPincludeSepaDisjunctive, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeSepaDisjunctive, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeSepaFlower(scip) @@ -16588,11 +50440,21 @@ function SCIPincludeSepaGomory(scip) end function SCIPincludeSepaImpliedbounds(scip) - ccall((:SCIPincludeSepaImpliedbounds, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeSepaImpliedbounds, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeSepaInterminor(scip) - ccall((:SCIPincludeSepaInterminor, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeSepaInterminor, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeSepaIntobj(scip) @@ -16600,7 +50462,12 @@ function SCIPincludeSepaIntobj(scip) end function SCIPincludeSepaLagromory(scip) - ccall((:SCIPincludeSepaLagromory, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeSepaLagromory, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeSepaMcf(scip) @@ -16620,7 +50487,12 @@ function SCIPincludeSepaOddcycle(scip) end function SCIPincludeSepaRapidlearning(scip) - ccall((:SCIPincludeSepaRapidlearning, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeSepaRapidlearning, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeSepaRlt(scip) @@ -16632,79 +50504,540 @@ function SCIPincludeSepaZerohalf(scip) end function SCIPprocessShellArguments(scip, argc, argv, defaultsetname) - ccall((:SCIPprocessShellArguments, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}), scip, argc, argv, defaultsetname) + ccall( + (:SCIPprocessShellArguments, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}), + scip, + argc, + argv, + defaultsetname, + ) end function SCIPrunShell(argc, argv, defaultsetname) - ccall((:SCIPrunShell, libscip), SCIP_RETCODE, (Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}), argc, argv, defaultsetname) + ccall( + (:SCIPrunShell, libscip), + SCIP_RETCODE, + (Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}), + argc, + argv, + defaultsetname, + ) end function SCIPgetSymInferredVarType(var) - ccall((:SCIPgetSymInferredVarType, libscip), SCIP_VARTYPE, (Ptr{SCIP_VAR},), var) -end - -function SCIPcomputeOrbitsSym(scip, issigned, permvars, npermvars, perms, nperms, orbits, orbitbegins, norbits) - ccall((:SCIPcomputeOrbitsSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{Cint}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, issigned, permvars, npermvars, perms, nperms, orbits, orbitbegins, norbits) -end - -function SCIPcomputeOrbitsFilterSym(scip, npermvars, permstrans, nperms, inactiveperms, orbits, orbitbegins, norbits, components, componentbegins, vartocomponent, componentblocked, ncomponents, nmovedpermvars) - ccall((:SCIPcomputeOrbitsFilterSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{Cint}}, Cint, Ptr{UInt8}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cuint}, Cint, Cint), scip, npermvars, permstrans, nperms, inactiveperms, orbits, orbitbegins, norbits, components, componentbegins, vartocomponent, componentblocked, ncomponents, nmovedpermvars) -end - -function SCIPcomputeOrbitsComponentsSym(scip, npermvars, permstrans, nperms, components, componentbegins, vartocomponent, ncomponents, orbits, orbitbegins, norbits, varorbitmap) - ccall((:SCIPcomputeOrbitsComponentsSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{Cint}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, npermvars, permstrans, nperms, components, componentbegins, vartocomponent, ncomponents, orbits, orbitbegins, norbits, varorbitmap) -end - -function SCIPcomputeOrbitVar(scip, npermvars, perms, permstrans, components, componentbegins, ignoredvars, varfound, varidx, component, orbit, orbitsize) - ccall((:SCIPcomputeOrbitVar, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cint, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt8}, Ptr{UInt8}, Cint, Cint, Ptr{Cint}, Ptr{Cint}), scip, npermvars, perms, permstrans, components, componentbegins, ignoredvars, varfound, varidx, component, orbit, orbitsize) -end - -function SCIPisInvolutionPerm(perm, vars, nvars, ntwocyclesperm, nbincyclesperm, earlytermination) - ccall((:SCIPisInvolutionPerm, libscip), SCIP_RETCODE, (Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}, Cuint), perm, vars, nvars, ntwocyclesperm, nbincyclesperm, earlytermination) -end - -function SCIPdetermineNVarsAffectedSym(scip, perms, nperms, permvars, npermvars, nvarsaffected) - ccall((:SCIPdetermineNVarsAffectedSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Cint}}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}), scip, perms, nperms, permvars, npermvars, nvarsaffected) -end - -function SCIPcomputeComponentsSym(scip, symtype, perms, nperms, permvars, npermvars, transposed, components, componentbegins, vartocomponent, componentblocked, ncomponents) - ccall((:SCIPcomputeComponentsSym, libscip), SCIP_RETCODE, (Ptr{SCIP}, SYM_SYMTYPE, Ptr{Ptr{Cint}}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cuint}}, Ptr{Cint}), scip, symtype, perms, nperms, permvars, npermvars, transposed, components, componentbegins, vartocomponent, componentblocked, ncomponents) -end - -function SCIPextendSubOrbitope(suborbitope, nrows, nfilledcols, coltoextend, perm, leftextension, nusedelems, permvars, rowisbinary, success, infeasible) - ccall((:SCIPextendSubOrbitope, libscip), SCIP_RETCODE, (Ptr{Ptr{Cint}}, Cint, Cint, Cint, Ptr{Cint}, Cuint, Ptr{Ptr{Cint}}, Ptr{Ptr{SCIP_VAR}}, Ptr{UInt8}, Ptr{Cuint}, Ptr{Cuint}), suborbitope, nrows, nfilledcols, coltoextend, perm, leftextension, nusedelems, permvars, rowisbinary, success, infeasible) -end - -function SCIPgenerateOrbitopeVarsMatrix(scip, vars, nrows, ncols, permvars, npermvars, orbitopevaridx, columnorder, nusedelems, rowisbinary, infeasible, storelexorder, lexorder, nvarsorder, maxnvarsorder) - ccall((:SCIPgenerateOrbitopeVarsMatrix, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, Cint, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}, Ptr{UInt8}, Ptr{Cuint}, Cuint, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}), scip, vars, nrows, ncols, permvars, npermvars, orbitopevaridx, columnorder, nusedelems, rowisbinary, infeasible, storelexorder, lexorder, nvarsorder, maxnvarsorder) -end - -function SCIPisPackingPartitioningOrbitope(scip, vars, nrows, ncols, pprows, npprows, type) - ccall((:SCIPisPackingPartitioningOrbitope, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{Ptr{SCIP_VAR}}}, Cint, Cint, Ptr{Ptr{Cuint}}, Ptr{Cint}, Ptr{SCIP_ORBITOPETYPE}), scip, vars, nrows, ncols, pprows, npprows, type) -end - -function SCIPdetectSingleOrDoubleLexMatrices(scip, detectsinglelex, perms, nperms, permlen, success, isorbitope, lexmatrix, nrows, ncols, lexrowsbegin, lexcolsbegin, nrowmatrices, ncolmatrices) - ccall((:SCIPdetectSingleOrDoubleLexMatrices, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint, Ptr{Ptr{Cint}}, Cint, Cint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Ptr{Cint}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cint}}, Ptr{Ptr{Cint}}, Ptr{Cint}, Ptr{Cint}), scip, detectsinglelex, perms, nperms, permlen, success, isorbitope, lexmatrix, nrows, ncols, lexrowsbegin, lexcolsbegin, nrowmatrices, ncolmatrices) + ccall( + (:SCIPgetSymInferredVarType, libscip), + SCIP_VARTYPE, + (Ptr{SCIP_VAR},), + var, + ) +end + +function SCIPcomputeOrbitsSym( + scip, + issigned, + permvars, + npermvars, + perms, + nperms, + orbits, + orbitbegins, + norbits, +) + ccall( + (:SCIPcomputeOrbitsSym, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cuint, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{Cint}}, + Cint, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + issigned, + permvars, + npermvars, + perms, + nperms, + orbits, + orbitbegins, + norbits, + ) +end + +function SCIPcomputeOrbitsFilterSym( + scip, + npermvars, + permstrans, + nperms, + inactiveperms, + orbits, + orbitbegins, + norbits, + components, + componentbegins, + vartocomponent, + componentblocked, + ncomponents, + nmovedpermvars, +) + ccall( + (:SCIPcomputeOrbitsFilterSym, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cint, + Ptr{Ptr{Cint}}, + Cint, + Ptr{UInt8}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cuint}, + Cint, + Cint, + ), + scip, + npermvars, + permstrans, + nperms, + inactiveperms, + orbits, + orbitbegins, + norbits, + components, + componentbegins, + vartocomponent, + componentblocked, + ncomponents, + nmovedpermvars, + ) +end + +function SCIPcomputeOrbitsComponentsSym( + scip, + npermvars, + permstrans, + nperms, + components, + componentbegins, + vartocomponent, + ncomponents, + orbits, + orbitbegins, + norbits, + varorbitmap, +) + ccall( + (:SCIPcomputeOrbitsComponentsSym, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cint, + Ptr{Ptr{Cint}}, + Cint, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Cint, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + npermvars, + permstrans, + nperms, + components, + componentbegins, + vartocomponent, + ncomponents, + orbits, + orbitbegins, + norbits, + varorbitmap, + ) +end + +function SCIPcomputeOrbitVar( + scip, + npermvars, + perms, + permstrans, + components, + componentbegins, + ignoredvars, + varfound, + varidx, + component, + orbit, + orbitsize, +) + ccall( + (:SCIPcomputeOrbitVar, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cint, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{UInt8}, + Ptr{UInt8}, + Cint, + Cint, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + npermvars, + perms, + permstrans, + components, + componentbegins, + ignoredvars, + varfound, + varidx, + component, + orbit, + orbitsize, + ) +end + +function SCIPisInvolutionPerm( + perm, + vars, + nvars, + ntwocyclesperm, + nbincyclesperm, + earlytermination, +) + ccall( + (:SCIPisInvolutionPerm, libscip), + SCIP_RETCODE, + (Ptr{Cint}, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}, Cuint), + perm, + vars, + nvars, + ntwocyclesperm, + nbincyclesperm, + earlytermination, + ) +end + +function SCIPdetermineNVarsAffectedSym( + scip, + perms, + nperms, + permvars, + npermvars, + nvarsaffected, +) + ccall( + (:SCIPdetermineNVarsAffectedSym, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{Cint}}, Cint, Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}), + scip, + perms, + nperms, + permvars, + npermvars, + nvarsaffected, + ) +end + +function SCIPcomputeComponentsSym( + scip, + symtype, + perms, + nperms, + permvars, + npermvars, + transposed, + components, + componentbegins, + vartocomponent, + componentblocked, + ncomponents, +) + ccall( + (:SCIPcomputeComponentsSym, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + SYM_SYMTYPE, + Ptr{Ptr{Cint}}, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Cuint, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cuint}}, + Ptr{Cint}, + ), + scip, + symtype, + perms, + nperms, + permvars, + npermvars, + transposed, + components, + componentbegins, + vartocomponent, + componentblocked, + ncomponents, + ) +end + +function SCIPextendSubOrbitope( + suborbitope, + nrows, + nfilledcols, + coltoextend, + perm, + leftextension, + nusedelems, + permvars, + rowisbinary, + success, + infeasible, +) + ccall( + (:SCIPextendSubOrbitope, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{Cint}}, + Cint, + Cint, + Cint, + Ptr{Cint}, + Cuint, + Ptr{Ptr{Cint}}, + Ptr{Ptr{SCIP_VAR}}, + Ptr{UInt8}, + Ptr{Cuint}, + Ptr{Cuint}, + ), + suborbitope, + nrows, + nfilledcols, + coltoextend, + perm, + leftextension, + nusedelems, + permvars, + rowisbinary, + success, + infeasible, + ) +end + +function SCIPgenerateOrbitopeVarsMatrix( + scip, + vars, + nrows, + ncols, + permvars, + npermvars, + orbitopevaridx, + columnorder, + nusedelems, + rowisbinary, + infeasible, + storelexorder, + lexorder, + nvarsorder, + maxnvarsorder, +) + ccall( + (:SCIPgenerateOrbitopeVarsMatrix, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{Ptr{Ptr{SCIP_VAR}}}}, + Cint, + Cint, + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{UInt8}, + Ptr{Cuint}, + Cuint, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + vars, + nrows, + ncols, + permvars, + npermvars, + orbitopevaridx, + columnorder, + nusedelems, + rowisbinary, + infeasible, + storelexorder, + lexorder, + nvarsorder, + maxnvarsorder, + ) +end + +function SCIPisPackingPartitioningOrbitope( + scip, + vars, + nrows, + ncols, + pprows, + npprows, + type, +) + ccall( + (:SCIPisPackingPartitioningOrbitope, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Cint, + Cint, + Ptr{Ptr{Cuint}}, + Ptr{Cint}, + Ptr{SCIP_ORBITOPETYPE}, + ), + scip, + vars, + nrows, + ncols, + pprows, + npprows, + type, + ) +end + +function SCIPdetectSingleOrDoubleLexMatrices( + scip, + detectsinglelex, + perms, + nperms, + permlen, + success, + isorbitope, + lexmatrix, + nrows, + ncols, + lexrowsbegin, + lexcolsbegin, + nrowmatrices, + ncolmatrices, +) + ccall( + (:SCIPdetectSingleOrDoubleLexMatrices, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Cuint, + Ptr{Ptr{Cint}}, + Cint, + Cint, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Ptr{Ptr{Cint}}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{Cint}}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + detectsinglelex, + perms, + nperms, + permlen, + success, + isorbitope, + lexmatrix, + nrows, + ncols, + lexrowsbegin, + lexcolsbegin, + nrowmatrices, + ncolmatrices, + ) end function SCIPsymEQ(scip, val1, val2) - ccall((:SCIPsymEQ, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPsymEQ, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPsymLE(scip, val1, val2) - ccall((:SCIPsymLE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPsymLE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPsymGE(scip, val1, val2) - ccall((:SCIPsymGE, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPsymGE, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPsymLT(scip, val1, val2) - ccall((:SCIPsymLT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPsymLT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPsymGT(scip, val1, val2) - ccall((:SCIPsymGT, libscip), Cuint, (Ptr{SCIP}, Cdouble, Cdouble), scip, val1, val2) + ccall( + (:SCIPsymGT, libscip), + Cuint, + (Ptr{SCIP}, Cdouble, Cdouble), + scip, + val1, + val2, + ) end function SCIPincludeTableDefault(scip) @@ -16712,15 +51045,32 @@ function SCIPincludeTableDefault(scip) end function SCIPincludeConcurrentScipSolvers(scip) - ccall((:SCIPincludeConcurrentScipSolvers, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeConcurrentScipSolvers, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeBendersDefault(scip) - ccall((:SCIPincludeBendersDefault, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeBendersDefault, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPcreateBendersDefault(scip, subproblems, nsubproblems) - ccall((:SCIPcreateBendersDefault, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP}}, Cint), scip, subproblems, nsubproblems) + ccall( + (:SCIPcreateBendersDefault, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP}}, Cint), + scip, + subproblems, + nsubproblems, + ) end function SCIPincludeRelaxBenders(scip) @@ -16728,43 +51078,216 @@ function SCIPincludeRelaxBenders(scip) end function SCIPgetMasterProblemRelaxBenders(scip) - ccall((:SCIPgetMasterProblemRelaxBenders, libscip), Ptr{SCIP}, (Ptr{SCIP},), scip) + ccall( + (:SCIPgetMasterProblemRelaxBenders, libscip), + Ptr{SCIP}, + (Ptr{SCIP},), + scip, + ) end function SCIPincludeCutselHybrid(scip) ccall((:SCIPincludeCutselHybrid, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) end -function SCIPselectCutsHybrid(scip, cuts, forcedcuts, randnumgen, goodscorefac, badscorefac, goodmaxparall, maxparall, dircutoffdistweight, efficacyweight, objparalweight, intsupportweight, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) - ccall((:SCIPselectCutsHybrid, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_RANDNUMGEN}, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, Cint, Ptr{Cint}), scip, cuts, forcedcuts, randnumgen, goodscorefac, badscorefac, goodmaxparall, maxparall, dircutoffdistweight, efficacyweight, objparalweight, intsupportweight, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) +function SCIPselectCutsHybrid( + scip, + cuts, + forcedcuts, + randnumgen, + goodscorefac, + badscorefac, + goodmaxparall, + maxparall, + dircutoffdistweight, + efficacyweight, + objparalweight, + intsupportweight, + ncuts, + nforcedcuts, + maxselectedcuts, + nselectedcuts, +) + ccall( + (:SCIPselectCutsHybrid, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{SCIP_RANDNUMGEN}, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cint, + Cint, + Cint, + Ptr{Cint}, + ), + scip, + cuts, + forcedcuts, + randnumgen, + goodscorefac, + badscorefac, + goodmaxparall, + maxparall, + dircutoffdistweight, + efficacyweight, + objparalweight, + intsupportweight, + ncuts, + nforcedcuts, + maxselectedcuts, + nselectedcuts, + ) end function SCIPincludeCutselDynamic(scip) - ccall((:SCIPincludeCutselDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPselectCutsDynamic(scip, cuts, forcedcuts, randnumgen, filtermode, mingain, maxparall, dircutoffdistweight, efficacyweight, objparalweight, intsupportweight, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) - ccall((:SCIPselectCutsDynamic, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_RANDNUMGEN}, Cchar, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cdouble, Cint, Cint, Cint, Ptr{Cint}), scip, cuts, forcedcuts, randnumgen, filtermode, mingain, maxparall, dircutoffdistweight, efficacyweight, objparalweight, intsupportweight, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) + ccall( + (:SCIPincludeCutselDynamic, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPselectCutsDynamic( + scip, + cuts, + forcedcuts, + randnumgen, + filtermode, + mingain, + maxparall, + dircutoffdistweight, + efficacyweight, + objparalweight, + intsupportweight, + ncuts, + nforcedcuts, + maxselectedcuts, + nselectedcuts, +) + ccall( + (:SCIPselectCutsDynamic, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{SCIP_RANDNUMGEN}, + Cchar, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cdouble, + Cint, + Cint, + Cint, + Ptr{Cint}, + ), + scip, + cuts, + forcedcuts, + randnumgen, + filtermode, + mingain, + maxparall, + dircutoffdistweight, + efficacyweight, + objparalweight, + intsupportweight, + ncuts, + nforcedcuts, + maxselectedcuts, + nselectedcuts, + ) end function SCIPincludeCutselEnsemble(scip) - ccall((:SCIPincludeCutselEnsemble, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) -end - -function SCIPselectCutsEnsemble(scip, cuts, forcedcuts, cutseldata, root, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) - ccall((:SCIPselectCutsEnsemble, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_CUTSELDATA}, Cuint, Cint, Cint, Cint, Ptr{Cint}), scip, cuts, forcedcuts, cutseldata, root, ncuts, nforcedcuts, maxselectedcuts, nselectedcuts) + ccall( + (:SCIPincludeCutselEnsemble, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) +end + +function SCIPselectCutsEnsemble( + scip, + cuts, + forcedcuts, + cutseldata, + root, + ncuts, + nforcedcuts, + maxselectedcuts, + nselectedcuts, +) + ccall( + (:SCIPselectCutsEnsemble, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{Ptr{SCIP_ROW}}, + Ptr{SCIP_CUTSELDATA}, + Cuint, + Cint, + Cint, + Cint, + Ptr{Cint}, + ), + scip, + cuts, + forcedcuts, + cutseldata, + root, + ncuts, + nforcedcuts, + maxselectedcuts, + nselectedcuts, + ) end function SCIPincludeExprhdlrVaridx(scip) - ccall((:SCIPincludeExprhdlrVaridx, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeExprhdlrVaridx, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPcreateExprVaridx(scip, expr, varidx, ownercreate, ownercreatedata) - ccall((:SCIPcreateExprVaridx, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Cvoid}, Ptr{Cvoid}), scip, expr, varidx, ownercreate, ownercreatedata) + ccall( + (:SCIPcreateExprVaridx, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_EXPR}}, Cint, Ptr{Cvoid}, Ptr{Cvoid}), + scip, + expr, + varidx, + ownercreate, + ownercreatedata, + ) end function SCIPisExprVaridx(scip, expr) - ccall((:SCIPisExprVaridx, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_EXPR}), scip, expr) + ccall( + (:SCIPisExprVaridx, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_EXPR}), + scip, + expr, + ) end function SCIPgetIndexExprVaridx(expr) @@ -16772,11 +51295,22 @@ function SCIPgetIndexExprVaridx(expr) end function SCIPsetIndexExprVaridx(expr, newindex) - ccall((:SCIPsetIndexExprVaridx, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint), expr, newindex) + ccall( + (:SCIPsetIndexExprVaridx, libscip), + Cvoid, + (Ptr{SCIP_EXPR}, Cint), + expr, + newindex, + ) end function SCIPincludeNlpSolverIpopt(scip) - ccall((:SCIPincludeNlpSolverIpopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlpSolverIpopt, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPgetSolverNameIpopt() @@ -16792,19 +51326,46 @@ function SCIPisIpoptAvailableIpopt() end function SCIPgetNlpiOracleIpopt(nlpiproblem) - ccall((:SCIPgetNlpiOracleIpopt, libscip), Ptr{Cvoid}, (Ptr{SCIP_NLPIPROBLEM},), nlpiproblem) + ccall( + (:SCIPgetNlpiOracleIpopt, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_NLPIPROBLEM},), + nlpiproblem, + ) end function SCIPcallLapackDsyevIpopt(computeeigenvectors, N, a, w) - ccall((:SCIPcallLapackDsyevIpopt, libscip), SCIP_RETCODE, (Cuint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), computeeigenvectors, N, a, w) + ccall( + (:SCIPcallLapackDsyevIpopt, libscip), + SCIP_RETCODE, + (Cuint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), + computeeigenvectors, + N, + a, + w, + ) end function SCIPsolveLinearEquationsIpopt(N, A, b, x, success) - ccall((:SCIPsolveLinearEquationsIpopt, libscip), SCIP_RETCODE, (Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), N, A, b, x, success) + ccall( + (:SCIPsolveLinearEquationsIpopt, libscip), + SCIP_RETCODE, + (Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}), + N, + A, + b, + x, + success, + ) end function SCIPincludeNlpSolverFilterSQP(scip) - ccall((:SCIPincludeNlpSolverFilterSQP, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlpSolverFilterSQP, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPgetSolverNameFilterSQP() @@ -16820,7 +51381,13 @@ function SCIPisFilterSQPAvailableFilterSQP() end function SCIPincludeNlpSolverWorhp(scip, useip) - ccall((:SCIPincludeNlpSolverWorhp, libscip), SCIP_RETCODE, (Ptr{SCIP}, Cuint), scip, useip) + ccall( + (:SCIPincludeNlpSolverWorhp, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Cuint), + scip, + useip, + ) end function SCIPgetSolverNameWorhp() @@ -16836,11 +51403,25 @@ function SCIPisWorhpAvailableWorhp() end function SCIPincludeNlpSolverConopt(scip) - ccall((:SCIPincludeNlpSolverConopt, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeNlpSolverConopt, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPsetLicenseConopt(nlpi, integer_1, integer_2, integer_3, text) - ccall((:SCIPsetLicenseConopt, libscip), Cvoid, (Ptr{SCIP_NLPI}, Cint, Cint, Cint, Ptr{Cchar}), nlpi, integer_1, integer_2, integer_3, text) + ccall( + (:SCIPsetLicenseConopt, libscip), + Cvoid, + (Ptr{SCIP_NLPI}, Cint, Cint, Cint, Ptr{Cchar}), + nlpi, + integer_1, + integer_2, + integer_3, + text, + ) end function SCIPgetSolverNameConopt() @@ -16860,111 +51441,316 @@ function SCIPincludeNlpSolverAll(scip) end function SCIPincludeDefaultPlugins(scip) - ccall((:SCIPincludeDefaultPlugins, libscip), SCIP_RETCODE, (Ptr{SCIP},), scip) + ccall( + (:SCIPincludeDefaultPlugins, libscip), + SCIP_RETCODE, + (Ptr{SCIP},), + scip, + ) end function SCIPbanditSelect(bandit, action) - ccall((:SCIPbanditSelect, libscip), SCIP_RETCODE, (Ptr{SCIP_BANDIT}, Ptr{Cint}), 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) + ccall( + (:SCIPbanditUpdate, libscip), + SCIP_RETCODE, + (Ptr{SCIP_BANDIT}, Cint, Cdouble), + bandit, + action, + score, + ) end function SCIPbanditvtableGetName(banditvtable) - ccall((:SCIPbanditvtableGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_BANDITVTABLE},), banditvtable) + ccall( + (:SCIPbanditvtableGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_BANDITVTABLE},), + banditvtable, + ) end function SCIPbanditGetRandnumgen(bandit) - ccall((:SCIPbanditGetRandnumgen, libscip), Ptr{SCIP_RANDNUMGEN}, (Ptr{SCIP_BANDIT},), bandit) + ccall( + (:SCIPbanditGetRandnumgen, libscip), + Ptr{SCIP_RANDNUMGEN}, + (Ptr{SCIP_BANDIT},), + bandit, + ) end function SCIPbanditGetNActions(bandit) ccall((:SCIPbanditGetNActions, libscip), Cint, (Ptr{SCIP_BANDIT},), bandit) end -function SCIPcreateBanditEpsgreedy(scip, epsgreedy, priorities, eps, usemodification, preferrecent, decayfactor, avglim, nactions, initseed) - ccall((:SCIPcreateBanditEpsgreedy, libscip), Cint, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, Cuint, Cuint, Cdouble, Cint, Cint, Cuint), scip, epsgreedy, priorities, eps, usemodification, preferrecent, decayfactor, avglim, nactions, initseed) +function SCIPcreateBanditEpsgreedy( + scip, + epsgreedy, + priorities, + eps, + usemodification, + preferrecent, + decayfactor, + avglim, + nactions, + initseed, +) + ccall( + (:SCIPcreateBanditEpsgreedy, libscip), + Cint, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_BANDIT}}, + Ptr{Cdouble}, + Cdouble, + Cuint, + Cuint, + Cdouble, + Cint, + Cint, + Cuint, + ), + scip, + epsgreedy, + priorities, + eps, + usemodification, + preferrecent, + decayfactor, + avglim, + nactions, + initseed, + ) end function SCIPgetWeightsEpsgreedy(epsgreedy) - ccall((:SCIPgetWeightsEpsgreedy, libscip), Ptr{Cdouble}, (Ptr{SCIP_BANDIT},), 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 - -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, Cuint), scip, exp3, priorities, gammaparam, beta, nactions, initseed) + ccall( + (:SCIPsetEpsilonEpsgreedy, libscip), + Cvoid, + (Ptr{SCIP_BANDIT}, Cdouble), + epsgreedy, + eps, + ) +end + +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, + Cuint, + ), + scip, + exp3, + priorities, + gammaparam, + beta, + nactions, + initseed, + ) end function SCIPsetGammaExp3(exp3, gammaparam) - ccall((:SCIPsetGammaExp3, libscip), Cvoid, (Ptr{SCIP_BANDIT}, Cdouble), 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) + 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) + ccall( + (:SCIPgetProbabilityExp3, libscip), + Cdouble, + (Ptr{SCIP_BANDIT}, Cint), + exp3, + action, + ) end function SCIPcreateBanditExp3IX(scip, exp3ix, priorities, nactions, initseed) - ccall((:SCIPcreateBanditExp3IX, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cint, Cuint), scip, exp3ix, priorities, nactions, initseed) + ccall( + (:SCIPcreateBanditExp3IX, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cint, Cuint), + scip, + exp3ix, + priorities, + nactions, + initseed, + ) end function SCIPgetProbabilityExp3IX(exp3ix, action) - ccall((:SCIPgetProbabilityExp3IX, libscip), Cdouble, (Ptr{SCIP_BANDIT}, Cint), exp3ix, action) + ccall( + (:SCIPgetProbabilityExp3IX, libscip), + Cdouble, + (Ptr{SCIP_BANDIT}, Cint), + exp3ix, + action, + ) end function SCIPcreateBanditUcb(scip, ucb, priorities, alpha, nactions, initseed) - ccall((:SCIPcreateBanditUcb, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, Cint, Cuint), scip, ucb, priorities, alpha, nactions, initseed) + ccall( + (:SCIPcreateBanditUcb, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_BANDIT}}, Ptr{Cdouble}, Cdouble, Cint, Cuint), + scip, + ucb, + priorities, + alpha, + nactions, + initseed, + ) end function SCIPgetConfidenceBoundUcb(ucb, action) - ccall((:SCIPgetConfidenceBoundUcb, libscip), Cdouble, (Ptr{SCIP_BANDIT}, Cint), 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) + ccall( + (:SCIPgetStartPermutationUcb, libscip), + Ptr{Cint}, + (Ptr{SCIP_BANDIT},), + ucb, + ) end function SCIPbendersComp(elem1, elem2) - ccall((:SCIPbendersComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPbendersCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPbendersGetData(benders) - ccall((:SCIPbendersGetData, libscip), Ptr{SCIP_BENDERSDATA}, (Ptr{SCIP_BENDERS},), 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) + ccall( + (:SCIPbendersSetData, libscip), + Cvoid, + (Ptr{SCIP_BENDERS}, Ptr{SCIP_BENDERSDATA}), + benders, + bendersdata, + ) end function SCIPbendersGetName(benders) - ccall((:SCIPbendersGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetDesc(benders) - ccall((:SCIPbendersGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetPriority(benders) - ccall((:SCIPbendersGetPriority, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetPriority, libscip), + Cint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetNSubproblems(benders) - ccall((:SCIPbendersGetNSubproblems, libscip), Cint, (Ptr{SCIP_BENDERS},), 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) + ccall( + (:SCIPbendersSubproblem, libscip), + Ptr{SCIP}, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbendersGetNCalls(benders) @@ -16972,31 +51758,66 @@ function SCIPbendersGetNCalls(benders) end function SCIPbendersGetNCutsFound(benders) - ccall((:SCIPbendersGetNCutsFound, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetNCutsFound, libscip), + Cint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetNStrengthenCutsFound(benders) - ccall((:SCIPbendersGetNStrengthenCutsFound, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetNStrengthenCutsFound, libscip), + Cint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetNStrengthenCalls(benders) - ccall((:SCIPbendersGetNStrengthenCalls, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetNStrengthenCalls, libscip), + Cint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetNStrengthenFails(benders) - ccall((:SCIPbendersGetNStrengthenFails, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetNStrengthenFails, libscip), + Cint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetSetupTime(benders) - ccall((:SCIPbendersGetSetupTime, libscip), Cdouble, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetTime(benders) - ccall((:SCIPbendersGetTime, libscip), Cdouble, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetTime, libscip), + Cdouble, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersIsInitialized(benders) - ccall((:SCIPbendersIsInitialized, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersIsInitialized, libscip), + Cuint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersIsActive(benders) @@ -17004,11 +51825,22 @@ function SCIPbendersIsActive(benders) end function SCIPbendersOnlyCheckConvexRelax(benders, subscipsoff) - ccall((:SCIPbendersOnlyCheckConvexRelax, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cuint), benders, subscipsoff) + ccall( + (:SCIPbendersOnlyCheckConvexRelax, libscip), + Cuint, + (Ptr{SCIP_BENDERS}, Cuint), + benders, + subscipsoff, + ) end function SCIPbendersGetNLPParam(benders) - ccall((:SCIPbendersGetNLPParam, libscip), SCIP_NLPPARAM, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetNLPParam, libscip), + SCIP_NLPPARAM, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersCutLP(benders) @@ -17016,327 +51848,858 @@ function SCIPbendersCutLP(benders) end function SCIPbendersCutPseudo(benders) - ccall((:SCIPbendersCutPseudo, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersCutPseudo, libscip), + Cuint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersCutRelaxation(benders) - ccall((:SCIPbendersCutRelaxation, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersCutRelaxation, libscip), + Cuint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersShareAuxVars(benders) - ccall((:SCIPbendersShareAuxVars, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersShareAuxVars, libscip), + Cuint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersSetSubproblemIsSetup(benders, probnumber, issetup) - ccall((:SCIPbendersSetSubproblemIsSetup, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cuint), benders, probnumber, issetup) + ccall( + (:SCIPbendersSetSubproblemIsSetup, libscip), + Cvoid, + (Ptr{SCIP_BENDERS}, Cint, Cuint), + benders, + probnumber, + issetup, + ) end function SCIPbendersSubproblemIsSetup(benders, probnumber) - ccall((:SCIPbendersSubproblemIsSetup, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) + ccall( + (:SCIPbendersSubproblemIsSetup, libscip), + Cuint, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbenderGetMasterAuxiliaryVar(benders) - ccall((:SCIPbenderGetMasterAuxiliaryVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbenderGetMasterAuxiliaryVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetAuxiliaryVar(benders, probnumber) - ccall((:SCIPbendersGetAuxiliaryVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BENDERS}, Cint), 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) + ccall( + (:SCIPbendersGetAuxiliaryVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetSubproblemMasterVars(benders, probnumber) - ccall((:SCIPbendersGetSubproblemMasterVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) + ccall( + (:SCIPbendersGetSubproblemMasterVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbendersGetNSubproblemMasterVars(benders, probnumber) - ccall((:SCIPbendersGetNSubproblemMasterVars, libscip), Cint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) -end - -function SCIPbendersGetSubproblemMasterVarsData(benders, probnumber, vars, nvars, nbinvars, nintvars) - ccall((:SCIPbendersGetSubproblemMasterVarsData, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), benders, probnumber, vars, nvars, nbinvars, nintvars) + ccall( + (:SCIPbendersGetNSubproblemMasterVars, libscip), + Cint, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) +end + +function SCIPbendersGetSubproblemMasterVarsData( + benders, + probnumber, + vars, + nvars, + nbinvars, + nintvars, +) + ccall( + (:SCIPbendersGetSubproblemMasterVarsData, libscip), + Cvoid, + ( + Ptr{SCIP_BENDERS}, + Cint, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + benders, + probnumber, + vars, + nvars, + nbinvars, + nintvars, + ) end function SCIPbendersSetSubproblemObjval(benders, probnumber, objval) - ccall((:SCIPbendersSetSubproblemObjval, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cdouble), 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) + ccall( + (:SCIPbendersGetSubproblemObjval, libscip), + Cdouble, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbendersGetNStoredCuts(benders) - ccall((:SCIPbendersGetNStoredCuts, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) -end - -function SCIPbendersGetStoredCutData(benders, cutidx, vars, vals, lhs, rhs, nvars) - ccall((:SCIPbendersGetStoredCutData, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERS}, Cint, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}), benders, cutidx, vars, vals, lhs, rhs, nvars) -end - -function SCIPbendersGetStoredCutOrigData(benders, cutidx, vars, vals, lhs, rhs, nvars, varssize) - ccall((:SCIPbendersGetStoredCutOrigData, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERS}, Cint, Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint), benders, cutidx, vars, vals, lhs, rhs, nvars, varssize) + ccall( + (:SCIPbendersGetNStoredCuts, libscip), + Cint, + (Ptr{SCIP_BENDERS},), + benders, + ) +end + +function SCIPbendersGetStoredCutData( + benders, + cutidx, + vars, + vals, + lhs, + rhs, + nvars, +) + ccall( + (:SCIPbendersGetStoredCutData, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_BENDERS}, + Cint, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Ptr{Cdouble}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + ), + benders, + cutidx, + vars, + vals, + lhs, + rhs, + nvars, + ) +end + +function SCIPbendersGetStoredCutOrigData( + benders, + cutidx, + vars, + vals, + lhs, + rhs, + nvars, + varssize, +) + ccall( + (:SCIPbendersGetStoredCutOrigData, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_BENDERS}, + Cint, + Ptr{Ptr{Ptr{SCIP_VAR}}}, + Ptr{Ptr{Cdouble}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Cint, + ), + benders, + cutidx, + vars, + vals, + lhs, + rhs, + nvars, + varssize, + ) end function SCIPfindBenderscut(benders, name) - ccall((:SCIPfindBenderscut, libscip), Ptr{SCIP_BENDERSCUT}, (Ptr{SCIP_BENDERS}, Ptr{Cchar}), benders, name) + ccall( + (:SCIPfindBenderscut, libscip), + Ptr{SCIP_BENDERSCUT}, + (Ptr{SCIP_BENDERS}, Ptr{Cchar}), + benders, + name, + ) end function SCIPbendersGetBenderscuts(benders) - ccall((:SCIPbendersGetBenderscuts, libscip), Ptr{Ptr{SCIP_BENDERSCUT}}, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetBenderscuts, libscip), + Ptr{Ptr{SCIP_BENDERSCUT}}, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetNBenderscuts(benders) - ccall((:SCIPbendersGetNBenderscuts, libscip), Cint, (Ptr{SCIP_BENDERS},), 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) + ccall( + (:SCIPbendersSetBenderscutPriority, libscip), + SCIP_RETCODE, + (Ptr{SCIP_BENDERS}, Ptr{SCIP_BENDERSCUT}, Cint), + benders, + benderscut, + priority, + ) end function SCIPbendersSolSlackVarsActive(benders, activeslack) - ccall((:SCIPbendersSolSlackVarsActive, libscip), SCIP_RETCODE, (Ptr{SCIP_BENDERS}, Ptr{Cuint}), benders, activeslack) + ccall( + (:SCIPbendersSolSlackVarsActive, libscip), + SCIP_RETCODE, + (Ptr{SCIP_BENDERS}, Ptr{Cuint}), + benders, + activeslack, + ) end function SCIPbendersSetSubproblemType(benders, probnumber, subprobtype) - ccall((:SCIPbendersSetSubproblemType, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, SCIP_BENDERSSUBTYPE), benders, probnumber, subprobtype) + ccall( + (:SCIPbendersSetSubproblemType, libscip), + Cvoid, + (Ptr{SCIP_BENDERS}, Cint, SCIP_BENDERSSUBTYPE), + benders, + probnumber, + subprobtype, + ) end function SCIPbendersGetSubproblemType(benders, probnumber) - ccall((:SCIPbendersGetSubproblemType, libscip), SCIP_BENDERSSUBTYPE, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) + ccall( + (:SCIPbendersGetSubproblemType, libscip), + SCIP_BENDERSSUBTYPE, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbendersSetSubproblemIsConvex(benders, probnumber, isconvex) - ccall((:SCIPbendersSetSubproblemIsConvex, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cuint), benders, probnumber, isconvex) + ccall( + (:SCIPbendersSetSubproblemIsConvex, libscip), + Cvoid, + (Ptr{SCIP_BENDERS}, Cint, Cuint), + benders, + probnumber, + isconvex, + ) end function SCIPbendersSubproblemIsConvex(benders, probnumber) - ccall((:SCIPbendersSubproblemIsConvex, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) + ccall( + (:SCIPbendersSubproblemIsConvex, libscip), + Cuint, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbendersGetNConvexSubproblems(benders) - ccall((:SCIPbendersGetNConvexSubproblems, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetNConvexSubproblems, libscip), + Cint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersSetSubproblemIsNonlinear(benders, probnumber, isnonlinear) - ccall((:SCIPbendersSetSubproblemIsNonlinear, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cuint), benders, probnumber, isnonlinear) + ccall( + (:SCIPbendersSetSubproblemIsNonlinear, libscip), + Cvoid, + (Ptr{SCIP_BENDERS}, Cint, Cuint), + benders, + probnumber, + isnonlinear, + ) end function SCIPbendersSubproblemIsNonlinear(benders, probnumber) - ccall((:SCIPbendersSubproblemIsNonlinear, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) + ccall( + (:SCIPbendersSubproblemIsNonlinear, libscip), + Cuint, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbendersGetNNonlinearSubproblems(benders) - ccall((:SCIPbendersGetNNonlinearSubproblems, libscip), Cint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetNNonlinearSubproblems, libscip), + Cint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersSetMasterIsNonlinear(benders, isnonlinear) - ccall((:SCIPbendersSetMasterIsNonlinear, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cuint), benders, isnonlinear) + ccall( + (:SCIPbendersSetMasterIsNonlinear, libscip), + Cvoid, + (Ptr{SCIP_BENDERS}, Cuint), + benders, + isnonlinear, + ) end function SCIPbendersMasterIsNonlinear(benders) - ccall((:SCIPbendersMasterIsNonlinear, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersMasterIsNonlinear, libscip), + Cuint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersGetObjectiveType(benders) - ccall((:SCIPbendersGetObjectiveType, libscip), SCIP_BENDERSOBJTYPE, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersGetObjectiveType, libscip), + SCIP_BENDERSOBJTYPE, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersInStrengthenRound(benders) - ccall((:SCIPbendersInStrengthenRound, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) + ccall( + (:SCIPbendersInStrengthenRound, libscip), + Cuint, + (Ptr{SCIP_BENDERS},), + benders, + ) end function SCIPbendersSubproblemsAreInfeasible(benders) - ccall((:SCIPbendersSubproblemsAreInfeasible, libscip), Cuint, (Ptr{SCIP_BENDERS},), benders) -end - -function SCIPbendersSolveSubproblemLP(scip, benders, probnumber, solvestatus, objective) - ccall((:SCIPbendersSolveSubproblemLP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{SCIP_STATUS}, Ptr{Cdouble}), scip, benders, probnumber, solvestatus, objective) -end - -function SCIPbendersSolveSubproblemCIP(scip, benders, probnumber, solvestatus, solvecip) - ccall((:SCIPbendersSolveSubproblemCIP, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{SCIP_STATUS}, Cuint), scip, benders, probnumber, solvestatus, solvecip) + ccall( + (:SCIPbendersSubproblemsAreInfeasible, libscip), + Cuint, + (Ptr{SCIP_BENDERS},), + benders, + ) +end + +function SCIPbendersSolveSubproblemLP( + scip, + benders, + probnumber, + solvestatus, + objective, +) + ccall( + (:SCIPbendersSolveSubproblemLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{SCIP_STATUS}, Ptr{Cdouble}), + scip, + benders, + probnumber, + solvestatus, + objective, + ) +end + +function SCIPbendersSolveSubproblemCIP( + scip, + benders, + probnumber, + solvestatus, + solvecip, +) + ccall( + (:SCIPbendersSolveSubproblemCIP, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_BENDERS}, Cint, Ptr{SCIP_STATUS}, Cuint), + scip, + benders, + probnumber, + solvestatus, + solvecip, + ) end function SCIPbendersGetNTransferredCuts(benders) - ccall((:SCIPbendersGetNTransferredCuts, libscip), Cint, (Ptr{SCIP_BENDERS},), 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) + 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) + ccall( + (:SCIPbendersGetSubproblemLowerbound, libscip), + Cdouble, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbendersSetSubproblemIsIndependent(benders, probnumber, isindep) - ccall((:SCIPbendersSetSubproblemIsIndependent, libscip), Cvoid, (Ptr{SCIP_BENDERS}, Cint, Cuint), benders, probnumber, isindep) + ccall( + (:SCIPbendersSetSubproblemIsIndependent, libscip), + Cvoid, + (Ptr{SCIP_BENDERS}, Cint, Cuint), + benders, + probnumber, + isindep, + ) end function SCIPbendersSubproblemIsIndependent(benders, probnumber) - ccall((:SCIPbendersSubproblemIsIndependent, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) + ccall( + (:SCIPbendersSubproblemIsIndependent, libscip), + Cuint, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbendersSubproblemIsEnabled(benders, probnumber) - ccall((:SCIPbendersSubproblemIsEnabled, libscip), Cuint, (Ptr{SCIP_BENDERS}, Cint), benders, probnumber) + ccall( + (:SCIPbendersSubproblemIsEnabled, libscip), + Cuint, + (Ptr{SCIP_BENDERS}, Cint), + benders, + probnumber, + ) end function SCIPbenderscutComp(elem1, elem2) - ccall((:SCIPbenderscutComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPbenderscutCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPbenderscutGetData(benderscut) - ccall((:SCIPbenderscutGetData, libscip), Ptr{SCIP_BENDERSCUTDATA}, (Ptr{SCIP_BENDERSCUT},), 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) + ccall( + (:SCIPbenderscutSetData, libscip), + Cvoid, + (Ptr{SCIP_BENDERSCUT}, Ptr{SCIP_BENDERSCUTDATA}), + benderscut, + benderscutdata, + ) end function SCIPbenderscutGetName(benderscut) - ccall((:SCIPbenderscutGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutGetDesc(benderscut) - ccall((:SCIPbenderscutGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutGetPriority(benderscut) - ccall((:SCIPbenderscutGetPriority, libscip), Cint, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutGetPriority, libscip), + Cint, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutGetNCalls(benderscut) - ccall((:SCIPbenderscutGetNCalls, libscip), Clonglong, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutGetNCalls, libscip), + Clonglong, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutGetNFound(benderscut) - ccall((:SCIPbenderscutGetNFound, libscip), Clonglong, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutGetNFound, libscip), + Clonglong, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutIsInitialized(benderscut) - ccall((:SCIPbenderscutIsInitialized, libscip), Cuint, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutIsInitialized, libscip), + Cuint, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutGetSetupTime(benderscut) - ccall((:SCIPbenderscutGetSetupTime, libscip), Cdouble, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutGetTime(benderscut) - ccall((:SCIPbenderscutGetTime, libscip), Cdouble, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutGetTime, libscip), + Cdouble, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutIsLPCut(benderscut) - ccall((:SCIPbenderscutIsLPCut, libscip), Cuint, (Ptr{SCIP_BENDERSCUT},), benderscut) + ccall( + (:SCIPbenderscutIsLPCut, libscip), + Cuint, + (Ptr{SCIP_BENDERSCUT},), + benderscut, + ) end function SCIPbenderscutSetEnabled(benderscut, enabled) - ccall((:SCIPbenderscutSetEnabled, libscip), Cvoid, (Ptr{SCIP_BENDERSCUT}, Cuint), benderscut, enabled) + ccall( + (:SCIPbenderscutSetEnabled, libscip), + Cvoid, + (Ptr{SCIP_BENDERSCUT}, Cuint), + benderscut, + enabled, + ) end function SCIPbranchruleComp(elem1, elem2) - ccall((:SCIPbranchruleComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPbranchruleCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPbranchruleGetData(branchrule) - ccall((:SCIPbranchruleGetData, libscip), Ptr{SCIP_BRANCHRULEDATA}, (Ptr{SCIP_BRANCHRULE},), 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) + ccall( + (:SCIPbranchruleSetData, libscip), + Cvoid, + (Ptr{SCIP_BRANCHRULE}, Ptr{SCIP_BRANCHRULEDATA}), + branchrule, + branchruledata, + ) end function SCIPbranchruleMarkExact(branchrule) - ccall((:SCIPbranchruleMarkExact, libscip), Cvoid, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleMarkExact, libscip), + Cvoid, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetName(branchrule) - ccall((:SCIPbranchruleGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetDesc(branchrule) - ccall((:SCIPbranchruleGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetPriority(branchrule) - ccall((:SCIPbranchruleGetPriority, libscip), Cint, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetPriority, libscip), + Cint, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetMaxdepth(branchrule) - ccall((:SCIPbranchruleGetMaxdepth, libscip), Cint, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetMaxdepth, libscip), + Cint, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetMaxbounddist(branchrule) - ccall((:SCIPbranchruleGetMaxbounddist, libscip), Cdouble, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetMaxbounddist, libscip), + Cdouble, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetSetupTime(branchrule) - ccall((:SCIPbranchruleGetSetupTime, libscip), Cdouble, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetTime(branchrule) - ccall((:SCIPbranchruleGetTime, libscip), Cdouble, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetTime, libscip), + Cdouble, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetNLPCalls(branchrule) - ccall((:SCIPbranchruleGetNLPCalls, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetNLPCalls, libscip), + Clonglong, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetNExternCalls(branchrule) - ccall((:SCIPbranchruleGetNExternCalls, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetNExternCalls, libscip), + Clonglong, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetNPseudoCalls(branchrule) - ccall((:SCIPbranchruleGetNPseudoCalls, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetNPseudoCalls, libscip), + Clonglong, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetNCutoffs(branchrule) - ccall((:SCIPbranchruleGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetNCutoffs, libscip), + Clonglong, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetNCutsFound(branchrule) - ccall((:SCIPbranchruleGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetNCutsFound, libscip), + Clonglong, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetNConssFound(branchrule) - ccall((:SCIPbranchruleGetNConssFound, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetNConssFound, libscip), + Clonglong, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetNDomredsFound(branchrule) - ccall((:SCIPbranchruleGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetNDomredsFound, libscip), + Clonglong, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleGetNChildren(branchrule) - ccall((:SCIPbranchruleGetNChildren, libscip), Clonglong, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleGetNChildren, libscip), + Clonglong, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPbranchruleIsInitialized(branchrule) - ccall((:SCIPbranchruleIsInitialized, libscip), Cuint, (Ptr{SCIP_BRANCHRULE},), branchrule) + ccall( + (:SCIPbranchruleIsInitialized, libscip), + Cuint, + (Ptr{SCIP_BRANCHRULE},), + branchrule, + ) end function SCIPcomprComp(elem1, elem2) - ccall((:SCIPcomprComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPcomprCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPcomprGetData(compr) - ccall((:SCIPcomprGetData, libscip), Ptr{SCIP_COMPRDATA}, (Ptr{SCIP_COMPR},), 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) + ccall( + (:SCIPcomprSetData, libscip), + Cvoid, + (Ptr{SCIP_COMPR}, Ptr{SCIP_COMPRDATA}), + compr, + comprdata, + ) end function SCIPcomprGetName(compr) @@ -17376,371 +52739,867 @@ function SCIPcomprGetTime(compr) end function SCIPconflicthdlrComp(elem1, elem2) - ccall((:SCIPconflicthdlrComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPconflicthdlrCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPconflicthdlrGetData(conflicthdlr) - ccall((:SCIPconflicthdlrGetData, libscip), Ptr{SCIP_CONFLICTHDLRDATA}, (Ptr{SCIP_CONFLICTHDLR},), 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) + ccall( + (:SCIPconflicthdlrSetData, libscip), + Cvoid, + (Ptr{SCIP_CONFLICTHDLR}, Ptr{SCIP_CONFLICTHDLRDATA}), + conflicthdlr, + conflicthdlrdata, + ) end function SCIPconflicthdlrGetName(conflicthdlr) - ccall((:SCIPconflicthdlrGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) + ccall( + (:SCIPconflicthdlrGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_CONFLICTHDLR},), + conflicthdlr, + ) end function SCIPconflicthdlrGetDesc(conflicthdlr) - ccall((:SCIPconflicthdlrGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) + ccall( + (:SCIPconflicthdlrGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_CONFLICTHDLR},), + conflicthdlr, + ) end function SCIPconflicthdlrGetPriority(conflicthdlr) - ccall((:SCIPconflicthdlrGetPriority, libscip), Cint, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) + ccall( + (:SCIPconflicthdlrGetPriority, libscip), + Cint, + (Ptr{SCIP_CONFLICTHDLR},), + conflicthdlr, + ) end function SCIPconflicthdlrIsInitialized(conflicthdlr) - ccall((:SCIPconflicthdlrIsInitialized, libscip), Cuint, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) + ccall( + (:SCIPconflicthdlrIsInitialized, libscip), + Cuint, + (Ptr{SCIP_CONFLICTHDLR},), + conflicthdlr, + ) end function SCIPconflicthdlrGetSetupTime(conflicthdlr) - ccall((:SCIPconflicthdlrGetSetupTime, libscip), Cdouble, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) + ccall( + (:SCIPconflicthdlrGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_CONFLICTHDLR},), + conflicthdlr, + ) end function SCIPconflicthdlrGetTime(conflicthdlr) - ccall((:SCIPconflicthdlrGetTime, libscip), Cdouble, (Ptr{SCIP_CONFLICTHDLR},), conflicthdlr) + ccall( + (:SCIPconflicthdlrGetTime, libscip), + Cdouble, + (Ptr{SCIP_CONFLICTHDLR},), + conflicthdlr, + ) end function SCIPconshdlrCompSepa(elem1, elem2) - ccall((:SCIPconshdlrCompSepa, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + 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) + ccall( + (:SCIPconshdlrCompCheck, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPconsCompCheck(elem1, elem2) - ccall((:SCIPconsCompCheck, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIPconsCompCheck, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPconshdlrGetName(conshdlr) - ccall((:SCIPconshdlrGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetDesc(conshdlr) - ccall((:SCIPconshdlrGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetData(conshdlr) - ccall((:SCIPconshdlrGetData, libscip), Ptr{SCIP_CONSHDLRDATA}, (Ptr{SCIP_CONSHDLR},), 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) + ccall( + (:SCIPconshdlrSetData, libscip), + Cvoid, + (Ptr{SCIP_CONSHDLR}, Ptr{SCIP_CONSHDLRDATA}), + conshdlr, + conshdlrdata, + ) end function SCIPconshdlrIsExact(conshdlr) - ccall((:SCIPconshdlrIsExact, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrIsExact, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrMarkExact(conshdlr) - ccall((:SCIPconshdlrMarkExact, libscip), Cvoid, (Ptr{SCIP_CONSHDLR},), conshdlr) -end - -function SCIPconshdlrSetSepa(conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) - ccall((:SCIPconshdlrSetSepa, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Cuint), conshdlr, conssepalp, conssepasol, sepafreq, sepapriority, delaysepa) -end - -function SCIPconshdlrSetProp(conshdlr, consprop, propfreq, delayprop, timingmask) - ccall((:SCIPconshdlrSetProp, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, Cuint, SCIP_PROPTIMING), conshdlr, consprop, propfreq, delayprop, timingmask) + ccall( + (:SCIPconshdlrMarkExact, libscip), + Cvoid, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) +end + +function SCIPconshdlrSetSepa( + conshdlr, + conssepalp, + conssepasol, + sepafreq, + sepapriority, + delaysepa, +) + ccall( + (:SCIPconshdlrSetSepa, libscip), + Cvoid, + (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Cuint), + conshdlr, + conssepalp, + conssepasol, + sepafreq, + sepapriority, + delaysepa, + ) +end + +function SCIPconshdlrSetProp( + conshdlr, + consprop, + propfreq, + delayprop, + timingmask, +) + ccall( + (:SCIPconshdlrSetProp, libscip), + Cvoid, + (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}, Cint, Cuint, SCIP_PROPTIMING), + conshdlr, + consprop, + propfreq, + delayprop, + timingmask, + ) end function SCIPconshdlrSetEnforelax(conshdlr, consenforelax) - ccall((:SCIPconshdlrSetEnforelax, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Ptr{Cvoid}), 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) + 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) + 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) + ccall( + (:SCIPconshdlrGetCheckConss, libscip), + Ptr{Ptr{SCIP_CONS}}, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetUpdateConss(conshdlr) - ccall((:SCIPconshdlrGetUpdateConss, libscip), Ptr{Ptr{SCIP_CONS}}, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetUpdateConss, libscip), + Ptr{Ptr{SCIP_CONS}}, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNConss(conshdlr) - ccall((:SCIPconshdlrGetNConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNEnfoConss(conshdlr) - ccall((:SCIPconshdlrGetNEnfoConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNEnfoConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNCheckConss(conshdlr) - ccall((:SCIPconshdlrGetNCheckConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNCheckConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNActiveConss(conshdlr) - ccall((:SCIPconshdlrGetNActiveConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNActiveConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNEnabledConss(conshdlr) - ccall((:SCIPconshdlrGetNEnabledConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNEnabledConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNUpdateConss(conshdlr) - ccall((:SCIPconshdlrGetNUpdateConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNUpdateConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetSetupTime(conshdlr) - ccall((:SCIPconshdlrGetSetupTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetPresolTime(conshdlr) - ccall((:SCIPconshdlrGetPresolTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetPresolTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetSepaTime(conshdlr) - ccall((:SCIPconshdlrGetSepaTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetSepaTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetEnfoLPTime(conshdlr) - ccall((:SCIPconshdlrGetEnfoLPTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetEnfoLPTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetEnfoPSTime(conshdlr) - ccall((:SCIPconshdlrGetEnfoPSTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetEnfoPSTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetEnfoRelaxTime(conshdlr) - ccall((:SCIPconshdlrGetEnfoRelaxTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetEnfoRelaxTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetPropTime(conshdlr) - ccall((:SCIPconshdlrGetPropTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetPropTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetStrongBranchPropTime(conshdlr) - ccall((:SCIPconshdlrGetStrongBranchPropTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetStrongBranchPropTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetCheckTime(conshdlr) - ccall((:SCIPconshdlrGetCheckTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetCheckTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetRespropTime(conshdlr) - ccall((:SCIPconshdlrGetRespropTime, libscip), Cdouble, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetRespropTime, libscip), + Cdouble, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNSepaCalls(conshdlr) - ccall((:SCIPconshdlrGetNSepaCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNSepaCalls, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNEnfoLPCalls(conshdlr) - ccall((:SCIPconshdlrGetNEnfoLPCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNEnfoLPCalls, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNEnfoPSCalls(conshdlr) - ccall((:SCIPconshdlrGetNEnfoPSCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNEnfoPSCalls, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNEnfoRelaxCalls(conshdlr) - ccall((:SCIPconshdlrGetNEnfoRelaxCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNEnfoRelaxCalls, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNPropCalls(conshdlr) - ccall((:SCIPconshdlrGetNPropCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNPropCalls, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNCheckCalls(conshdlr) - ccall((:SCIPconshdlrGetNCheckCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNCheckCalls, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNRespropCalls(conshdlr) - ccall((:SCIPconshdlrGetNRespropCalls, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNRespropCalls, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNCutoffs(conshdlr) - ccall((:SCIPconshdlrGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNCutoffs, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNCutsFound(conshdlr) - ccall((:SCIPconshdlrGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNCutsFound, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNCutsApplied(conshdlr) - ccall((:SCIPconshdlrGetNCutsApplied, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNCutsApplied, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNConssFound(conshdlr) - ccall((:SCIPconshdlrGetNConssFound, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNConssFound, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNDomredsFound(conshdlr) - ccall((:SCIPconshdlrGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNDomredsFound, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNChildren(conshdlr) - ccall((:SCIPconshdlrGetNChildren, libscip), Clonglong, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNChildren, libscip), + Clonglong, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetMaxNActiveConss(conshdlr) - ccall((:SCIPconshdlrGetMaxNActiveConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetMaxNActiveConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetStartNActiveConss(conshdlr) - ccall((:SCIPconshdlrGetStartNActiveConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetStartNActiveConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNFixedVars(conshdlr) - ccall((:SCIPconshdlrGetNFixedVars, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNFixedVars, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNAggrVars(conshdlr) - ccall((:SCIPconshdlrGetNAggrVars, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNAggrVars, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNChgVarTypes(conshdlr) - ccall((:SCIPconshdlrGetNChgVarTypes, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNChgVarTypes, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNChgBds(conshdlr) - ccall((:SCIPconshdlrGetNChgBds, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNChgBds, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNAddHoles(conshdlr) - ccall((:SCIPconshdlrGetNAddHoles, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNAddHoles, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNDelConss(conshdlr) - ccall((:SCIPconshdlrGetNDelConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNDelConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNAddConss(conshdlr) - ccall((:SCIPconshdlrGetNAddConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNAddConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNUpgdConss(conshdlr) - ccall((:SCIPconshdlrGetNUpgdConss, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNUpgdConss, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNChgCoefs(conshdlr) - ccall((:SCIPconshdlrGetNChgCoefs, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNChgCoefs, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNChgSides(conshdlr) - ccall((:SCIPconshdlrGetNChgSides, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNChgSides, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetNPresolCalls(conshdlr) - ccall((:SCIPconshdlrGetNPresolCalls, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetNPresolCalls, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetSepaPriority(conshdlr) - ccall((:SCIPconshdlrGetSepaPriority, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetSepaPriority, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetEnfoPriority(conshdlr) - ccall((:SCIPconshdlrGetEnfoPriority, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetEnfoPriority, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetCheckPriority(conshdlr) - ccall((:SCIPconshdlrGetCheckPriority, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetCheckPriority, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetSepaFreq(conshdlr) - ccall((:SCIPconshdlrGetSepaFreq, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetSepaFreq, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetPropFreq(conshdlr) - ccall((:SCIPconshdlrGetPropFreq, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetPropFreq, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetEagerFreq(conshdlr) - ccall((:SCIPconshdlrGetEagerFreq, libscip), Cint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrGetEagerFreq, libscip), + Cint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrNeedsCons(conshdlr) - ccall((:SCIPconshdlrNeedsCons, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrNeedsCons, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrSetNeedsCons(conshdlr, needscons) - ccall((:SCIPconshdlrSetNeedsCons, libscip), Cvoid, (Ptr{SCIP_CONSHDLR}, Cuint), conshdlr, needscons) + ccall( + (:SCIPconshdlrSetNeedsCons, libscip), + Cvoid, + (Ptr{SCIP_CONSHDLR}, Cuint), + conshdlr, + needscons, + ) end function SCIPconshdlrDoesPresolve(conshdlr) - ccall((:SCIPconshdlrDoesPresolve, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrDoesPresolve, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrIsSeparationDelayed(conshdlr) - ccall((:SCIPconshdlrIsSeparationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrIsSeparationDelayed, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrIsPropagationDelayed(conshdlr) - ccall((:SCIPconshdlrIsPropagationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrIsPropagationDelayed, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrWasLPSeparationDelayed(conshdlr) - ccall((:SCIPconshdlrWasLPSeparationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrWasLPSeparationDelayed, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrWasSolSeparationDelayed(conshdlr) - ccall((:SCIPconshdlrWasSolSeparationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrWasSolSeparationDelayed, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrWasPropagationDelayed(conshdlr) - ccall((:SCIPconshdlrWasPropagationDelayed, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrWasPropagationDelayed, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrIsInitialized(conshdlr) - ccall((:SCIPconshdlrIsInitialized, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrIsInitialized, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrIsClonable(conshdlr) - ccall((:SCIPconshdlrIsClonable, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrIsClonable, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrGetPropTiming(conshdlr) - ccall((:SCIPconshdlrGetPropTiming, libscip), SCIP_PROPTIMING, (Ptr{SCIP_CONSHDLR},), 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) + 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) + ccall( + (:SCIPconshdlrSetPropTiming, libscip), + Cvoid, + (Ptr{SCIP_CONSHDLR}, SCIP_PROPTIMING), + conshdlr, + proptiming, + ) end function SCIPconshdlrGetPresolTiming(conshdlr) - ccall((:SCIPconshdlrGetPresolTiming, libscip), SCIP_PRESOLTIMING, (Ptr{SCIP_CONSHDLR},), 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) + ccall( + (:SCIPconshdlrSetPresolTiming, libscip), + Cvoid, + (Ptr{SCIP_CONSHDLR}, SCIP_PRESOLTIMING), + conshdlr, + presoltiming, + ) end function SCIPconshdlrSupportsPermsymDetection(conshdlr) - ccall((:SCIPconshdlrSupportsPermsymDetection, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrSupportsPermsymDetection, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconshdlrSupportsSignedPermsymDetection(conshdlr) - ccall((:SCIPconshdlrSupportsSignedPermsymDetection, libscip), Cuint, (Ptr{SCIP_CONSHDLR},), conshdlr) + ccall( + (:SCIPconshdlrSupportsSignedPermsymDetection, libscip), + Cuint, + (Ptr{SCIP_CONSHDLR},), + conshdlr, + ) end function SCIPconsGetName(cons) @@ -17752,11 +53611,21 @@ function SCIPconsGetPos(cons) end function SCIPconsGetHdlr(cons) - ccall((:SCIPconsGetHdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP_CONS},), 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) + ccall( + (:SCIPconsGetData, libscip), + Ptr{SCIP_CONSDATA}, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPconsGetNUses(cons) @@ -17776,7 +53645,12 @@ function SCIPconsIsActive(cons) end function SCIPconsIsUpdatedeactivate(cons) - ccall((:SCIPconsIsUpdatedeactivate, libscip), Cuint, (Ptr{SCIP_CONS},), cons) + ccall( + (:SCIPconsIsUpdatedeactivate, libscip), + Cuint, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPconsIsEnabled(cons) @@ -17784,11 +53658,21 @@ function SCIPconsIsEnabled(cons) end function SCIPconsIsSeparationEnabled(cons) - ccall((:SCIPconsIsSeparationEnabled, libscip), Cuint, (Ptr{SCIP_CONS},), cons) + ccall( + (:SCIPconsIsSeparationEnabled, libscip), + Cuint, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPconsIsPropagationEnabled(cons) - ccall((:SCIPconsIsPropagationEnabled, libscip), Cuint, (Ptr{SCIP_CONS},), cons) + ccall( + (:SCIPconsIsPropagationEnabled, libscip), + Cuint, + (Ptr{SCIP_CONS},), + cons, + ) end function SCIPconsIsDeleted(cons) @@ -17888,23 +53772,53 @@ function SCIPconsGetNLocksNeg(cons) end function SCIPconsIsLockedTypePos(cons, locktype) - ccall((:SCIPconsIsLockedTypePos, libscip), Cuint, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) + ccall( + (:SCIPconsIsLockedTypePos, libscip), + Cuint, + (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), + cons, + locktype, + ) end function SCIPconsIsLockedTypeNeg(cons, locktype) - ccall((:SCIPconsIsLockedTypeNeg, libscip), Cuint, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) + ccall( + (:SCIPconsIsLockedTypeNeg, libscip), + Cuint, + (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), + cons, + locktype, + ) end function SCIPconsIsLockedType(cons, locktype) - ccall((:SCIPconsIsLockedType, libscip), Cuint, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), cons, locktype) + ccall( + (:SCIPconsIsLockedType, libscip), + Cuint, + (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), + cons, + locktype, + ) end function SCIPconsGetNLocksTypePos(cons, locktype) - ccall((:SCIPconsGetNLocksTypePos, libscip), Cint, (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), 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) + ccall( + (:SCIPconsGetNLocksTypeNeg, libscip), + Cint, + (Ptr{SCIP_CONS}, SCIP_LOCKTYPE), + cons, + locktype, + ) end function SCIPconsIsAdded(cons) @@ -17912,7 +53826,13 @@ function SCIPconsIsAdded(cons) end function SCIPconsAddUpgradeLocks(cons, nlocks) - ccall((:SCIPconsAddUpgradeLocks, libscip), Cvoid, (Ptr{SCIP_CONS}, Cint), cons, nlocks) + ccall( + (:SCIPconsAddUpgradeLocks, libscip), + Cvoid, + (Ptr{SCIP_CONS}, Cint), + cons, + nlocks, + ) end function SCIPconsGetNUpgradeLocks(cons) @@ -17920,31 +53840,73 @@ function SCIPconsGetNUpgradeLocks(cons) end function SCIPlinConsStatsCreate(scip, linconsstats) - ccall((:SCIPlinConsStatsCreate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_LINCONSSTATS}}), 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) + ccall( + (:SCIPlinConsStatsFree, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{SCIP_LINCONSSTATS}}), + scip, + linconsstats, + ) end function SCIPlinConsStatsReset(linconsstats) - ccall((:SCIPlinConsStatsReset, libscip), Cvoid, (Ptr{SCIP_LINCONSSTATS},), 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) + ccall( + (:SCIPlinConsStatsGetTypeCount, libscip), + Cint, + (Ptr{SCIP_LINCONSSTATS}, SCIP_LINCONSTYPE), + linconsstats, + linconstype, + ) end function SCIPlinConsStatsGetSum(linconsstats) - ccall((:SCIPlinConsStatsGetSum, libscip), Cint, (Ptr{SCIP_LINCONSSTATS},), 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) + 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{Libc.FILE}, Ptr{SCIP_LINCONSSTATS}), scip, file, linconsstats) + ccall( + (:SCIPprintLinConsStats, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Libc.FILE}, Ptr{SCIP_LINCONSSTATS}), + scip, + file, + linconsstats, + ) end function SCIPcutGetRow(cut) @@ -17960,7 +53922,12 @@ function SCIPcutGetLPActivityQuot(cut) end function SCIPcutpoolGetCuts(cutpool) - ccall((:SCIPcutpoolGetCuts, libscip), Ptr{Ptr{SCIP_CUT}}, (Ptr{SCIP_CUTPOOL},), cutpool) + ccall( + (:SCIPcutpoolGetCuts, libscip), + Ptr{Ptr{SCIP_CUT}}, + (Ptr{SCIP_CUTPOOL},), + cutpool, + ) end function SCIPcutpoolGetNCuts(cutpool) @@ -17968,39 +53935,84 @@ function SCIPcutpoolGetNCuts(cutpool) end function SCIPcutpoolGetMaxNCuts(cutpool) - ccall((:SCIPcutpoolGetMaxNCuts, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) + ccall( + (:SCIPcutpoolGetMaxNCuts, libscip), + Clonglong, + (Ptr{SCIP_CUTPOOL},), + cutpool, + ) end function SCIPcutpoolGetTime(cutpool) - ccall((:SCIPcutpoolGetTime, libscip), Cdouble, (Ptr{SCIP_CUTPOOL},), cutpool) + ccall( + (:SCIPcutpoolGetTime, libscip), + Cdouble, + (Ptr{SCIP_CUTPOOL},), + cutpool, + ) end function SCIPcutpoolGetNCalls(cutpool) - ccall((:SCIPcutpoolGetNCalls, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) + ccall( + (:SCIPcutpoolGetNCalls, libscip), + Clonglong, + (Ptr{SCIP_CUTPOOL},), + cutpool, + ) end function SCIPcutpoolGetNRootCalls(cutpool) - ccall((:SCIPcutpoolGetNRootCalls, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) + ccall( + (:SCIPcutpoolGetNRootCalls, libscip), + Clonglong, + (Ptr{SCIP_CUTPOOL},), + cutpool, + ) end function SCIPcutpoolGetNCutsFound(cutpool) - ccall((:SCIPcutpoolGetNCutsFound, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) + ccall( + (:SCIPcutpoolGetNCutsFound, libscip), + Clonglong, + (Ptr{SCIP_CUTPOOL},), + cutpool, + ) end function SCIPcutpoolGetNCutsAdded(cutpool) - ccall((:SCIPcutpoolGetNCutsAdded, libscip), Clonglong, (Ptr{SCIP_CUTPOOL},), cutpool) + ccall( + (:SCIPcutpoolGetNCutsAdded, libscip), + Clonglong, + (Ptr{SCIP_CUTPOOL},), + cutpool, + ) end function SCIPcutselGetName(cutsel) - ccall((:SCIPcutselGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetData(cutsel) - ccall((:SCIPcutselGetData, libscip), Ptr{SCIP_CUTSELDATA}, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetData, libscip), + Ptr{SCIP_CUTSELDATA}, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetDesc(cutsel) - ccall((:SCIPcutselGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetPriority(cutsel) @@ -18008,15 +54020,31 @@ function SCIPcutselGetPriority(cutsel) end function SCIPcutselSetData(cutsel, cutseldata) - ccall((:SCIPcutselSetData, libscip), Cvoid, (Ptr{SCIP_CUTSEL}, Ptr{SCIP_CUTSELDATA}), cutsel, cutseldata) + ccall( + (:SCIPcutselSetData, libscip), + Cvoid, + (Ptr{SCIP_CUTSEL}, Ptr{SCIP_CUTSELDATA}), + cutsel, + cutseldata, + ) end function SCIPcutselIsInitialized(cutsel) - ccall((:SCIPcutselIsInitialized, libscip), Cuint, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselIsInitialized, libscip), + Cuint, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetSetupTime(cutsel) - ccall((:SCIPcutselGetSetupTime, libscip), Cdouble, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetTime(cutsel) @@ -18024,83 +54052,211 @@ function SCIPcutselGetTime(cutsel) end function SCIPcutselGetNCalls(cutsel) - ccall((:SCIPcutselGetNCalls, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetNCalls, libscip), + Clonglong, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetNRootCalls(cutsel) - ccall((:SCIPcutselGetNRootCalls, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetNRootCalls, libscip), + Clonglong, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetNRootCuts(cutsel) - ccall((:SCIPcutselGetNRootCuts, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetNRootCuts, libscip), + Clonglong, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetNRootForcedCuts(cutsel) - ccall((:SCIPcutselGetNRootForcedCuts, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetNRootForcedCuts, libscip), + Clonglong, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetNRootCutsFiltered(cutsel) - ccall((:SCIPcutselGetNRootCutsFiltered, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetNRootCutsFiltered, libscip), + Clonglong, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetNLocalCuts(cutsel) - ccall((:SCIPcutselGetNLocalCuts, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetNLocalCuts, libscip), + Clonglong, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetNLocalForcedCuts(cutsel) - ccall((:SCIPcutselGetNLocalForcedCuts, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetNLocalForcedCuts, libscip), + Clonglong, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselGetNLocalCutsFiltered(cutsel) - ccall((:SCIPcutselGetNLocalCutsFiltered, libscip), Clonglong, (Ptr{SCIP_CUTSEL},), cutsel) + ccall( + (:SCIPcutselGetNLocalCutsFiltered, libscip), + Clonglong, + (Ptr{SCIP_CUTSEL},), + cutsel, + ) end function SCIPcutselComp(elem1, elem2) - ccall((:SCIPcutselComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIPcutselComp, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPdatatreeGetBool(datatree, name, value) - ccall((:SCIPdatatreeGetBool, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cuint}), datatree, name, value) + ccall( + (:SCIPdatatreeGetBool, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cuint}), + datatree, + name, + value, + ) end function SCIPdatatreeGetLong(datatree, name, value) - ccall((:SCIPdatatreeGetLong, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Clonglong}), datatree, name, value) + ccall( + (:SCIPdatatreeGetLong, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Clonglong}), + datatree, + name, + value, + ) end function SCIPdatatreeGetReal(datatree, name, value) - ccall((:SCIPdatatreeGetReal, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cdouble}), datatree, name, value) + ccall( + (:SCIPdatatreeGetReal, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Cdouble}), + datatree, + name, + value, + ) end function SCIPdatatreeGetString(datatree, name, value) - ccall((:SCIPdatatreeGetString, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), datatree, name, value) + ccall( + (:SCIPdatatreeGetString, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), + datatree, + name, + value, + ) end function SCIPdatatreeGetBoolArray(datatree, name, values, nvalues) - ccall((:SCIPdatatreeGetBoolArray, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cuint}}, Ptr{Cint}), datatree, name, values, nvalues) + ccall( + (:SCIPdatatreeGetBoolArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cuint}}, Ptr{Cint}), + datatree, + name, + values, + nvalues, + ) end function SCIPdatatreeGetLongArray(datatree, name, values, nvalues) - ccall((:SCIPdatatreeGetLongArray, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Clonglong}}, Ptr{Cint}), datatree, name, values, nvalues) + ccall( + (:SCIPdatatreeGetLongArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Clonglong}}, Ptr{Cint}), + datatree, + name, + values, + nvalues, + ) end function SCIPdatatreeGetRealArray(datatree, name, values, nvalues) - ccall((:SCIPdatatreeGetRealArray, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cdouble}}, Ptr{Cint}), datatree, name, values, nvalues) + ccall( + (:SCIPdatatreeGetRealArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Cdouble}}, Ptr{Cint}), + datatree, + name, + values, + nvalues, + ) end function SCIPdatatreeGetStringArray(datatree, name, values, nvalues) - ccall((:SCIPdatatreeGetStringArray, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Ptr{Cchar}}}, Ptr{Cint}), datatree, name, values, nvalues) + ccall( + (:SCIPdatatreeGetStringArray, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{Ptr{Cchar}}}, Ptr{Cint}), + datatree, + name, + values, + nvalues, + ) end function SCIPdatatreeGetTree(datatree, name, value) - ccall((:SCIPdatatreeGetTree, libscip), SCIP_RETCODE, (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{SCIP_DATATREE}}), datatree, name, value) + ccall( + (:SCIPdatatreeGetTree, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DATATREE}, Ptr{Cchar}, Ptr{Ptr{SCIP_DATATREE}}), + datatree, + name, + value, + ) end function SCIPdecompCreate(decomp, blkmem, nblocks, original, benderslabels) - ccall((:SCIPdecompCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_DECOMP}}, Ptr{BMS_BLKMEM}, Cint, Cuint, Cuint), decomp, blkmem, nblocks, original, benderslabels) + ccall( + (:SCIPdecompCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_DECOMP}}, Ptr{BMS_BLKMEM}, Cint, Cuint, Cuint), + decomp, + blkmem, + nblocks, + original, + benderslabels, + ) end function SCIPdecompFree(decomp, blkmem) - ccall((:SCIPdecompFree, libscip), Cvoid, (Ptr{Ptr{SCIP_DECOMP}}, Ptr{BMS_BLKMEM}), decomp, blkmem) + ccall( + (:SCIPdecompFree, libscip), + Cvoid, + (Ptr{Ptr{SCIP_DECOMP}}, Ptr{BMS_BLKMEM}), + decomp, + blkmem, + ) end function SCIPdecompIsOriginal(decomp) @@ -18108,11 +54264,22 @@ function SCIPdecompIsOriginal(decomp) end function SCIPdecompSetUseBendersLabels(decomp, benderslabels) - ccall((:SCIPdecompSetUseBendersLabels, libscip), Cvoid, (Ptr{SCIP_DECOMP}, Cuint), decomp, benderslabels) + ccall( + (:SCIPdecompSetUseBendersLabels, libscip), + Cvoid, + (Ptr{SCIP_DECOMP}, Cuint), + decomp, + benderslabels, + ) end function SCIPdecompUseBendersLabels(decomp) - ccall((:SCIPdecompUseBendersLabels, libscip), Cuint, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompUseBendersLabels, libscip), + Cuint, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetNBlocks(decomp) @@ -18120,131 +54287,343 @@ function SCIPdecompGetNBlocks(decomp) end function SCIPdecompGetAreaScore(decomp) - ccall((:SCIPdecompGetAreaScore, libscip), Cdouble, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetAreaScore, libscip), + Cdouble, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetModularity(decomp) - ccall((:SCIPdecompGetModularity, libscip), Cdouble, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetModularity, libscip), + Cdouble, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetVarsSize(decomp, varssize, nlabels) - ccall((:SCIPdecompGetVarsSize, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Ptr{Cint}, Cint), decomp, varssize, nlabels) + ccall( + (:SCIPdecompGetVarsSize, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DECOMP}, Ptr{Cint}, Cint), + decomp, + varssize, + nlabels, + ) end function SCIPdecompGetConssSize(decomp, consssize, nlabels) - ccall((:SCIPdecompGetConssSize, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Ptr{Cint}, Cint), decomp, consssize, nlabels) + ccall( + (:SCIPdecompGetConssSize, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DECOMP}, Ptr{Cint}, Cint), + decomp, + consssize, + nlabels, + ) end function SCIPdecompGetNBorderVars(decomp) - ccall((:SCIPdecompGetNBorderVars, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetNBorderVars, libscip), + Cint, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetNBorderConss(decomp) - ccall((:SCIPdecompGetNBorderConss, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetNBorderConss, libscip), + Cint, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetNBlockGraphEdges(decomp) - ccall((:SCIPdecompGetNBlockGraphEdges, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetNBlockGraphEdges, libscip), + Cint, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetNBlockGraphComponents(decomp) - ccall((:SCIPdecompGetNBlockGraphComponents, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetNBlockGraphComponents, libscip), + Cint, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetNBlockGraphArticulations(decomp) - ccall((:SCIPdecompGetNBlockGraphArticulations, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetNBlockGraphArticulations, libscip), + Cint, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetBlockGraphMaxDegree(decomp) - ccall((:SCIPdecompGetBlockGraphMaxDegree, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetBlockGraphMaxDegree, libscip), + Cint, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompGetBlockGraphMinDegree(decomp) - ccall((:SCIPdecompGetBlockGraphMinDegree, libscip), Cint, (Ptr{SCIP_DECOMP},), decomp) + ccall( + (:SCIPdecompGetBlockGraphMinDegree, libscip), + Cint, + (Ptr{SCIP_DECOMP},), + decomp, + ) end function SCIPdecompSetVarsLabels(decomp, vars, labels, nvars) - ccall((:SCIPdecompSetVarsLabels, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), decomp, vars, labels, nvars) + ccall( + (:SCIPdecompSetVarsLabels, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), + decomp, + vars, + labels, + nvars, + ) end function SCIPdecompGetVarsLabels(decomp, vars, labels, nvars) - ccall((:SCIPdecompGetVarsLabels, libscip), Cvoid, (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), decomp, vars, labels, nvars) + ccall( + (:SCIPdecompGetVarsLabels, libscip), + Cvoid, + (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_VAR}}, Ptr{Cint}, Cint), + decomp, + vars, + labels, + nvars, + ) end function SCIPdecompSetConsLabels(decomp, conss, labels, nconss) - ccall((:SCIPdecompSetConsLabels, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), decomp, conss, labels, nconss) + ccall( + (:SCIPdecompSetConsLabels, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), + decomp, + conss, + labels, + nconss, + ) end function SCIPdecompGetConsLabels(decomp, conss, labels, nconss) - ccall((:SCIPdecompGetConsLabels, libscip), Cvoid, (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), decomp, conss, labels, nconss) + ccall( + (:SCIPdecompGetConsLabels, libscip), + Cvoid, + (Ptr{SCIP_DECOMP}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), + decomp, + conss, + labels, + nconss, + ) end function SCIPdecompClear(decomp, clearvarlabels, clearconslabels) - ccall((:SCIPdecompClear, libscip), SCIP_RETCODE, (Ptr{SCIP_DECOMP}, Cuint, Cuint), decomp, clearvarlabels, clearconslabels) + ccall( + (:SCIPdecompClear, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DECOMP}, Cuint, Cuint), + decomp, + clearvarlabels, + clearconslabels, + ) end function SCIPdecompPrintStats(decomp, strbuf) - ccall((:SCIPdecompPrintStats, libscip), Ptr{Cchar}, (Ptr{SCIP_DECOMP}, Ptr{Cchar}), decomp, strbuf) + ccall( + (:SCIPdecompPrintStats, libscip), + Ptr{Cchar}, + (Ptr{SCIP_DECOMP}, Ptr{Cchar}), + decomp, + strbuf, + ) end function SCIPdialoghdlrGetRoot(dialoghdlr) - ccall((:SCIPdialoghdlrGetRoot, libscip), Ptr{SCIP_DIALOG}, (Ptr{SCIP_DIALOGHDLR},), dialoghdlr) + ccall( + (:SCIPdialoghdlrGetRoot, libscip), + Ptr{SCIP_DIALOG}, + (Ptr{SCIP_DIALOGHDLR},), + dialoghdlr, + ) end function SCIPdialoghdlrClearBuffer(dialoghdlr) - ccall((:SCIPdialoghdlrClearBuffer, libscip), Cvoid, (Ptr{SCIP_DIALOGHDLR},), dialoghdlr) + ccall( + (:SCIPdialoghdlrClearBuffer, libscip), + Cvoid, + (Ptr{SCIP_DIALOGHDLR},), + dialoghdlr, + ) end function SCIPdialoghdlrIsBufferEmpty(dialoghdlr) - ccall((:SCIPdialoghdlrIsBufferEmpty, libscip), Cuint, (Ptr{SCIP_DIALOGHDLR},), dialoghdlr) + ccall( + (:SCIPdialoghdlrIsBufferEmpty, libscip), + Cuint, + (Ptr{SCIP_DIALOGHDLR},), + dialoghdlr, + ) end function SCIPdialoghdlrGetLine(dialoghdlr, dialog, prompt, inputline, endoffile) - ccall((:SCIPdialoghdlrGetLine, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), dialoghdlr, dialog, prompt, inputline, endoffile) + ccall( + (:SCIPdialoghdlrGetLine, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_DIALOGHDLR}, + Ptr{SCIP_DIALOG}, + Ptr{Cchar}, + Ptr{Ptr{Cchar}}, + Ptr{Cuint}, + ), + dialoghdlr, + dialog, + prompt, + inputline, + endoffile, + ) end function SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, inputword, endoffile) - ccall((:SCIPdialoghdlrGetWord, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Ptr{Cchar}, Ptr{Ptr{Cchar}}, Ptr{Cuint}), dialoghdlr, dialog, prompt, inputword, endoffile) + ccall( + (:SCIPdialoghdlrGetWord, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_DIALOGHDLR}, + Ptr{SCIP_DIALOG}, + Ptr{Cchar}, + Ptr{Ptr{Cchar}}, + Ptr{Cuint}, + ), + dialoghdlr, + dialog, + prompt, + inputword, + endoffile, + ) end function SCIPdialoghdlrAddInputLine(dialoghdlr, inputline) - ccall((:SCIPdialoghdlrAddInputLine, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{Cchar}), dialoghdlr, inputline) + ccall( + (:SCIPdialoghdlrAddInputLine, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DIALOGHDLR}, Ptr{Cchar}), + dialoghdlr, + inputline, + ) end function SCIPdialoghdlrAddHistory(dialoghdlr, dialog, command, escapecommand) - ccall((:SCIPdialoghdlrAddHistory, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Ptr{Cchar}, Cuint), dialoghdlr, dialog, command, escapecommand) + ccall( + (:SCIPdialoghdlrAddHistory, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DIALOGHDLR}, Ptr{SCIP_DIALOG}, Ptr{Cchar}, Cuint), + dialoghdlr, + dialog, + command, + escapecommand, + ) end function SCIPdialogHasEntry(dialog, entryname) - ccall((:SCIPdialogHasEntry, libscip), Cuint, (Ptr{SCIP_DIALOG}, Ptr{Cchar}), dialog, entryname) + ccall( + (:SCIPdialogHasEntry, libscip), + Cuint, + (Ptr{SCIP_DIALOG}, Ptr{Cchar}), + dialog, + entryname, + ) end function SCIPdialogFindEntry(dialog, entryname, subdialog) - ccall((:SCIPdialogFindEntry, libscip), Cint, (Ptr{SCIP_DIALOG}, Ptr{Cchar}, Ptr{Ptr{SCIP_DIALOG}}), dialog, entryname, subdialog) + ccall( + (:SCIPdialogFindEntry, libscip), + Cint, + (Ptr{SCIP_DIALOG}, Ptr{Cchar}, Ptr{Ptr{SCIP_DIALOG}}), + dialog, + entryname, + subdialog, + ) end function SCIPdialogDisplayMenu(dialog, scip) - ccall((:SCIPdialogDisplayMenu, libscip), SCIP_RETCODE, (Ptr{SCIP_DIALOG}, Ptr{SCIP}), 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) + 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}, Ptr{Cchar}), dialog, scip, entryname) + ccall( + (:SCIPdialogDisplayCompletions, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DIALOG}, Ptr{SCIP}, Ptr{Cchar}), + dialog, + scip, + entryname, + ) end function SCIPdialogGetPath(dialog, sepchar, path) - ccall((:SCIPdialogGetPath, libscip), Cvoid, (Ptr{SCIP_DIALOG}, Cchar, Ptr{Cchar}), dialog, sepchar, path) + ccall( + (:SCIPdialogGetPath, libscip), + Cvoid, + (Ptr{SCIP_DIALOG}, Cchar, Ptr{Cchar}), + dialog, + sepchar, + path, + ) end function SCIPdialogGetName(dialog) - ccall((:SCIPdialogGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_DIALOG},), dialog) + ccall( + (:SCIPdialogGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_DIALOG},), + dialog, + ) end function SCIPdialogGetDesc(dialog) - ccall((:SCIPdialogGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_DIALOG},), dialog) + ccall( + (:SCIPdialogGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_DIALOG},), + dialog, + ) end function SCIPdialogIsSubmenu(dialog) @@ -18252,23 +54631,49 @@ function SCIPdialogIsSubmenu(dialog) end function SCIPdialogGetParent(dialog) - ccall((:SCIPdialogGetParent, libscip), Ptr{SCIP_DIALOG}, (Ptr{SCIP_DIALOG},), 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) + ccall( + (:SCIPdialogGetSubdialogs, libscip), + Ptr{Ptr{SCIP_DIALOG}}, + (Ptr{SCIP_DIALOG},), + dialog, + ) end function SCIPdialogGetNSubdialogs(dialog) - ccall((:SCIPdialogGetNSubdialogs, libscip), Cint, (Ptr{SCIP_DIALOG},), dialog) + ccall( + (:SCIPdialogGetNSubdialogs, libscip), + Cint, + (Ptr{SCIP_DIALOG},), + dialog, + ) end function SCIPdialogGetData(dialog) - ccall((:SCIPdialogGetData, libscip), Ptr{SCIP_DIALOGDATA}, (Ptr{SCIP_DIALOG},), 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) + ccall( + (:SCIPdialogSetData, libscip), + Cvoid, + (Ptr{SCIP_DIALOG}, Ptr{SCIP_DIALOGDATA}), + dialog, + dialogdata, + ) end function SCIPdialogIsHidden(dialog) @@ -18280,15 +54685,31 @@ function SCIPdialogSetHidden(dialog) end function SCIPdialogWriteHistory(filename) - ccall((:SCIPdialogWriteHistory, libscip), SCIP_RETCODE, (Ptr{Cchar},), filename) + ccall( + (:SCIPdialogWriteHistory, libscip), + SCIP_RETCODE, + (Ptr{Cchar},), + filename, + ) end function SCIPdispGetData(disp) - ccall((:SCIPdispGetData, libscip), Ptr{SCIP_DISPDATA}, (Ptr{SCIP_DISP},), 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) + ccall( + (:SCIPdispSetData, libscip), + Cvoid, + (Ptr{SCIP_DISP}, Ptr{SCIP_DISPDATA}), + disp, + dispdata, + ) end function SCIPdispGetName(disp) @@ -18316,7 +54737,12 @@ function SCIPdispGetPosition(disp) end function SCIPdispGetStatus(disp) - ccall((:SCIPdispGetStatus, libscip), SCIP_DISPSTATUS, (Ptr{SCIP_DISP},), disp) + ccall( + (:SCIPdispGetStatus, libscip), + SCIP_DISPSTATUS, + (Ptr{SCIP_DISP},), + disp, + ) end function SCIPdispIsInitialized(disp) @@ -18324,43 +54750,103 @@ function SCIPdispIsInitialized(disp) end function SCIPdispLongint(messagehdlr, file, val, width) - ccall((:SCIPdispLongint, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Clonglong, Cint), messagehdlr, file, val, width) + ccall( + (:SCIPdispLongint, libscip), + Cvoid, + (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Clonglong, Cint), + messagehdlr, + file, + val, + width, + ) end function SCIPdispInt(messagehdlr, file, val, width) - ccall((:SCIPdispInt, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Cint, Cint), messagehdlr, file, val, width) + ccall( + (:SCIPdispInt, libscip), + Cvoid, + (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Cint, Cint), + messagehdlr, + file, + val, + width, + ) end function SCIPdispTime(messagehdlr, file, val, width) - ccall((:SCIPdispTime, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Cdouble, Cint), messagehdlr, file, val, width) + ccall( + (:SCIPdispTime, libscip), + Cvoid, + (Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}, Cdouble, Cint), + messagehdlr, + file, + val, + width, + ) end function SCIPeventhdlrGetName(eventhdlr) - ccall((:SCIPeventhdlrGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_EVENTHDLR},), eventhdlr) + ccall( + (:SCIPeventhdlrGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_EVENTHDLR},), + eventhdlr, + ) end function SCIPeventhdlrGetData(eventhdlr) - ccall((:SCIPeventhdlrGetData, libscip), Ptr{SCIP_EVENTHDLRDATA}, (Ptr{SCIP_EVENTHDLR},), 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) + ccall( + (:SCIPeventhdlrSetData, libscip), + Cvoid, + (Ptr{SCIP_EVENTHDLR}, Ptr{SCIP_EVENTHDLRDATA}), + eventhdlr, + eventhdlrdata, + ) end function SCIPeventhdlrIsInitialized(eventhdlr) - ccall((:SCIPeventhdlrIsInitialized, libscip), Cuint, (Ptr{SCIP_EVENTHDLR},), eventhdlr) + ccall( + (:SCIPeventhdlrIsInitialized, libscip), + Cuint, + (Ptr{SCIP_EVENTHDLR},), + eventhdlr, + ) end function SCIPeventhdlrGetSetupTime(eventhdlr) - ccall((:SCIPeventhdlrGetSetupTime, libscip), Cdouble, (Ptr{SCIP_EVENTHDLR},), eventhdlr) + ccall( + (:SCIPeventhdlrGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_EVENTHDLR},), + eventhdlr, + ) end function SCIPeventhdlrGetTime(eventhdlr) - ccall((:SCIPeventhdlrGetTime, libscip), Cdouble, (Ptr{SCIP_EVENTHDLR},), eventhdlr) + ccall( + (:SCIPeventhdlrGetTime, libscip), + Cdouble, + (Ptr{SCIP_EVENTHDLR},), + eventhdlr, + ) end function SCIPeventGetType(event) - ccall((:SCIPeventGetType, libscip), SCIP_EVENTTYPE, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetType, libscip), + SCIP_EVENTTYPE, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetVar(event) @@ -18380,7 +54866,12 @@ function SCIPeventGetOldbound(event) end function SCIPeventGetOldboundExact(event) - ccall((:SCIPeventGetOldboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetOldboundExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetNewbound(event) @@ -18388,23 +54879,48 @@ function SCIPeventGetNewbound(event) end function SCIPeventGetOldtype(event) - ccall((:SCIPeventGetOldtype, libscip), SCIP_VARTYPE, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetOldtype, libscip), + SCIP_VARTYPE, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetNewtype(event) - ccall((:SCIPeventGetNewtype, libscip), SCIP_VARTYPE, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetNewtype, libscip), + SCIP_VARTYPE, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetOldImpltype(event) - ccall((:SCIPeventGetOldImpltype, libscip), SCIP_IMPLINTTYPE, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetOldImpltype, libscip), + SCIP_IMPLINTTYPE, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetNewImpltype(event) - ccall((:SCIPeventGetNewImpltype, libscip), SCIP_IMPLINTTYPE, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetNewImpltype, libscip), + SCIP_IMPLINTTYPE, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetNode(event) - ccall((:SCIPeventGetNode, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetNode, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetSol(event) @@ -18424,219 +54940,511 @@ function SCIPeventGetRow(event) end function SCIPeventGetRowCol(event) - ccall((:SCIPeventGetRowCol, libscip), Ptr{SCIP_COL}, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetRowCol, libscip), + Ptr{SCIP_COL}, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetRowOldCoefVal(event) - ccall((:SCIPeventGetRowOldCoefVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetRowOldCoefVal, libscip), + Cdouble, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetRowNewCoefVal(event) - ccall((:SCIPeventGetRowNewCoefVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetRowNewCoefVal, libscip), + Cdouble, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetRowOldConstVal(event) - ccall((:SCIPeventGetRowOldConstVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetRowOldConstVal, libscip), + Cdouble, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetRowNewConstVal(event) - ccall((:SCIPeventGetRowNewConstVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetRowNewConstVal, libscip), + Cdouble, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetRowSide(event) - ccall((:SCIPeventGetRowSide, libscip), SCIP_SIDETYPE, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetRowSide, libscip), + SCIP_SIDETYPE, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetRowOldSideVal(event) - ccall((:SCIPeventGetRowOldSideVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetRowOldSideVal, libscip), + Cdouble, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPeventGetRowNewSideVal(event) - ccall((:SCIPeventGetRowNewSideVal, libscip), Cdouble, (Ptr{SCIP_EVENT},), event) + ccall( + (:SCIPeventGetRowNewSideVal, libscip), + Cdouble, + (Ptr{SCIP_EVENT},), + event, + ) end function SCIPexprhdlrSetCopyFreeHdlr(exprhdlr, copyhdlr, freehdlr) - ccall((:SCIPexprhdlrSetCopyFreeHdlr, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), exprhdlr, copyhdlr, freehdlr) + ccall( + (:SCIPexprhdlrSetCopyFreeHdlr, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), + exprhdlr, + copyhdlr, + freehdlr, + ) end function SCIPexprhdlrSetCopyFreeData(exprhdlr, copydata, freedata) - ccall((:SCIPexprhdlrSetCopyFreeData, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), exprhdlr, copydata, freedata) + ccall( + (:SCIPexprhdlrSetCopyFreeData, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), + exprhdlr, + copydata, + freedata, + ) end function SCIPexprhdlrSetPrint(exprhdlr, print) - ccall((:SCIPexprhdlrSetPrint, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, print) + ccall( + (:SCIPexprhdlrSetPrint, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + print, + ) end function SCIPexprhdlrSetParse(exprhdlr, parse) - ccall((:SCIPexprhdlrSetParse, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, parse) + ccall( + (:SCIPexprhdlrSetParse, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + parse, + ) end function SCIPexprhdlrSetCurvature(exprhdlr, curvature) - ccall((:SCIPexprhdlrSetCurvature, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, curvature) + ccall( + (:SCIPexprhdlrSetCurvature, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + curvature, + ) end function SCIPexprhdlrSetMonotonicity(exprhdlr, monotonicity) - ccall((:SCIPexprhdlrSetMonotonicity, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, monotonicity) + ccall( + (:SCIPexprhdlrSetMonotonicity, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + monotonicity, + ) end function SCIPexprhdlrSetIntegrality(exprhdlr, integrality) - ccall((:SCIPexprhdlrSetIntegrality, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, integrality) + ccall( + (:SCIPexprhdlrSetIntegrality, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + integrality, + ) end function SCIPexprhdlrSetHash(exprhdlr, hash) - ccall((:SCIPexprhdlrSetHash, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, hash) + ccall( + (:SCIPexprhdlrSetHash, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + hash, + ) end function SCIPexprhdlrSetCompare(exprhdlr, compare) - ccall((:SCIPexprhdlrSetCompare, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, compare) + ccall( + (:SCIPexprhdlrSetCompare, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + compare, + ) end function SCIPexprhdlrSetDiff(exprhdlr, bwdiff, fwdiff, bwfwdiff) - ccall((:SCIPexprhdlrSetDiff, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), exprhdlr, bwdiff, fwdiff, bwfwdiff) + ccall( + (:SCIPexprhdlrSetDiff, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), + exprhdlr, + bwdiff, + fwdiff, + bwfwdiff, + ) end function SCIPexprhdlrSetIntEval(exprhdlr, inteval) - ccall((:SCIPexprhdlrSetIntEval, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, inteval) + ccall( + (:SCIPexprhdlrSetIntEval, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + inteval, + ) end function SCIPexprhdlrSetSimplify(exprhdlr, simplify) - ccall((:SCIPexprhdlrSetSimplify, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, simplify) + ccall( + (:SCIPexprhdlrSetSimplify, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + simplify, + ) end function SCIPexprhdlrSetReverseProp(exprhdlr, reverseprop) - ccall((:SCIPexprhdlrSetReverseProp, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, reverseprop) + ccall( + (:SCIPexprhdlrSetReverseProp, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + reverseprop, + ) end function SCIPexprhdlrSetEstimate(exprhdlr, initestimates, estimate) - ccall((:SCIPexprhdlrSetEstimate, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), exprhdlr, initestimates, estimate) + ccall( + (:SCIPexprhdlrSetEstimate, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), + exprhdlr, + initestimates, + estimate, + ) end function SCIPexprhdlrSetGetSymdata(exprhdlr, getsymdata) - ccall((:SCIPexprhdlrSetGetSymdata, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), exprhdlr, getsymdata) + ccall( + (:SCIPexprhdlrSetGetSymdata, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Ptr{Cvoid}), + exprhdlr, + getsymdata, + ) end function SCIPexprhdlrGetName(exprhdlr) - ccall((:SCIPexprhdlrGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetDescription(exprhdlr) - ccall((:SCIPexprhdlrGetDescription, libscip), Ptr{Cchar}, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetDescription, libscip), + Ptr{Cchar}, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetPrecedence(exprhdlr) - ccall((:SCIPexprhdlrGetPrecedence, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetPrecedence, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetData(exprhdlr) - ccall((:SCIPexprhdlrGetData, libscip), Ptr{SCIP_EXPRHDLRDATA}, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetData, libscip), + Ptr{SCIP_EXPRHDLRDATA}, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasPrint(exprhdlr) - ccall((:SCIPexprhdlrHasPrint, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasPrint, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasBwdiff(exprhdlr) - ccall((:SCIPexprhdlrHasBwdiff, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasBwdiff, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasFwdiff(exprhdlr) - ccall((:SCIPexprhdlrHasFwdiff, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasFwdiff, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasIntEval(exprhdlr) - ccall((:SCIPexprhdlrHasIntEval, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasIntEval, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasEstimate(exprhdlr) - ccall((:SCIPexprhdlrHasEstimate, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasEstimate, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasInitEstimates(exprhdlr) - ccall((:SCIPexprhdlrHasInitEstimates, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasInitEstimates, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasSimplify(exprhdlr) - ccall((:SCIPexprhdlrHasSimplify, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasSimplify, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasCurvature(exprhdlr) - ccall((:SCIPexprhdlrHasCurvature, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasCurvature, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasMonotonicity(exprhdlr) - ccall((:SCIPexprhdlrHasMonotonicity, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasMonotonicity, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasReverseProp(exprhdlr) - ccall((:SCIPexprhdlrHasReverseProp, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasReverseProp, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrHasGetSymData(exprhdlr) - ccall((:SCIPexprhdlrHasGetSymData, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrHasGetSymData, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrComp(elem1, elem2) - ccall((:SCIPexprhdlrComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIPexprhdlrComp, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPexprhdlrGetNCreated(exprhdlr) - ccall((:SCIPexprhdlrGetNCreated, libscip), Cuint, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNCreated, libscip), + Cuint, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetNIntevalCalls(exprhdlr) - ccall((:SCIPexprhdlrGetNIntevalCalls, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNIntevalCalls, libscip), + Clonglong, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetIntevalTime(exprhdlr) - ccall((:SCIPexprhdlrGetIntevalTime, libscip), Cdouble, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetIntevalTime, libscip), + Cdouble, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetNReversepropCalls(exprhdlr) - ccall((:SCIPexprhdlrGetNReversepropCalls, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNReversepropCalls, libscip), + Clonglong, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetReversepropTime(exprhdlr) - ccall((:SCIPexprhdlrGetReversepropTime, libscip), Cdouble, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetReversepropTime, libscip), + Cdouble, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetNCutoffs(exprhdlr) - ccall((:SCIPexprhdlrGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNCutoffs, libscip), + Clonglong, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetNDomainReductions(exprhdlr) - ccall((:SCIPexprhdlrGetNDomainReductions, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNDomainReductions, libscip), + Clonglong, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrIncrementNDomainReductions(exprhdlr, nreductions) - ccall((:SCIPexprhdlrIncrementNDomainReductions, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR}, Cint), exprhdlr, nreductions) + ccall( + (:SCIPexprhdlrIncrementNDomainReductions, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR}, Cint), + exprhdlr, + nreductions, + ) end function SCIPexprhdlrGetNEstimateCalls(exprhdlr) - ccall((:SCIPexprhdlrGetNEstimateCalls, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNEstimateCalls, libscip), + Clonglong, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetEstimateTime(exprhdlr) - ccall((:SCIPexprhdlrGetEstimateTime, libscip), Cdouble, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetEstimateTime, libscip), + Cdouble, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetNBranchings(exprhdlr) - ccall((:SCIPexprhdlrGetNBranchings, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNBranchings, libscip), + Clonglong, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrIncrementNBranchings(exprhdlr) - ccall((:SCIPexprhdlrIncrementNBranchings, libscip), Cvoid, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrIncrementNBranchings, libscip), + Cvoid, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetNSimplifyCalls(exprhdlr) - ccall((:SCIPexprhdlrGetNSimplifyCalls, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNSimplifyCalls, libscip), + Clonglong, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetSimplifyTime(exprhdlr) - ccall((:SCIPexprhdlrGetSimplifyTime, libscip), Cdouble, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetSimplifyTime, libscip), + Cdouble, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprhdlrGetNSimplifications(exprhdlr) - ccall((:SCIPexprhdlrGetNSimplifications, libscip), Clonglong, (Ptr{SCIP_EXPRHDLR},), exprhdlr) + ccall( + (:SCIPexprhdlrGetNSimplifications, libscip), + Clonglong, + (Ptr{SCIP_EXPRHDLR},), + exprhdlr, + ) end function SCIPexprGetNUses(expr) @@ -18648,23 +55456,49 @@ function SCIPexprGetNChildren(expr) end function SCIPexprGetChildren(expr) - ccall((:SCIPexprGetChildren, libscip), Ptr{Ptr{SCIP_EXPR}}, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprGetChildren, libscip), + Ptr{Ptr{SCIP_EXPR}}, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPexprGetHdlr(expr) - ccall((:SCIPexprGetHdlr, libscip), Ptr{SCIP_EXPRHDLR}, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprGetHdlr, libscip), + Ptr{SCIP_EXPRHDLR}, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPexprGetData(expr) - ccall((:SCIPexprGetData, libscip), Ptr{SCIP_EXPRDATA}, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprGetData, libscip), + Ptr{SCIP_EXPRDATA}, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPexprSetData(expr, exprdata) - ccall((:SCIPexprSetData, libscip), Cvoid, (Ptr{SCIP_EXPR}, Ptr{SCIP_EXPRDATA}), expr, exprdata) + ccall( + (:SCIPexprSetData, libscip), + Cvoid, + (Ptr{SCIP_EXPR}, Ptr{SCIP_EXPRDATA}), + expr, + exprdata, + ) end function SCIPexprGetOwnerData(expr) - ccall((:SCIPexprGetOwnerData, libscip), Ptr{SCIP_EXPR_OWNERDATA}, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprGetOwnerData, libscip), + Ptr{SCIP_EXPR_OWNERDATA}, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPexprGetEvalValue(expr) @@ -18692,27 +55526,60 @@ function SCIPexprGetDiffTag(expr) end function SCIPexprGetActivity(expr) - ccall((:SCIPexprGetActivity, libscip), SCIP_INTERVAL, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprGetActivity, libscip), + SCIP_INTERVAL, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPexprGetActivityTag(expr) - ccall((:SCIPexprGetActivityTag, libscip), Clonglong, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprGetActivityTag, libscip), + Clonglong, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPexprSetActivity(expr, activity, activitytag) - ccall((:SCIPexprSetActivity, libscip), Cvoid, (Ptr{SCIP_EXPR}, SCIP_INTERVAL, Clonglong), expr, activity, activitytag) + ccall( + (:SCIPexprSetActivity, libscip), + Cvoid, + (Ptr{SCIP_EXPR}, SCIP_INTERVAL, Clonglong), + expr, + activity, + activitytag, + ) end function SCIPexprGetCurvature(expr) - ccall((:SCIPexprGetCurvature, libscip), SCIP_EXPRCURV, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprGetCurvature, libscip), + SCIP_EXPRCURV, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPexprSetCurvature(expr, curvature) - ccall((:SCIPexprSetCurvature, libscip), Cvoid, (Ptr{SCIP_EXPR}, SCIP_EXPRCURV), expr, curvature) + ccall( + (:SCIPexprSetCurvature, libscip), + Cvoid, + (Ptr{SCIP_EXPR}, SCIP_EXPRCURV), + expr, + curvature, + ) end function SCIPexprGetIntegrality(expr) - ccall((:SCIPexprGetIntegrality, libscip), SCIP_IMPLINTTYPE, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprGetIntegrality, libscip), + SCIP_IMPLINTTYPE, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPexprIsIntegral(expr) @@ -18720,23 +55587,124 @@ function SCIPexprIsIntegral(expr) end function SCIPexprSetIntegrality(expr, integrality) - ccall((:SCIPexprSetIntegrality, libscip), Cvoid, (Ptr{SCIP_EXPR}, SCIP_IMPLINTTYPE), expr, integrality) -end - -function SCIPexprGetQuadraticData(expr, constant, nlinexprs, linexprs, lincoefs, nquadexprs, nbilinexprs, eigenvalues, eigenvectors) - ccall((:SCIPexprGetQuadraticData, libscip), Cvoid, (Ptr{SCIP_EXPR}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Ptr{SCIP_EXPR}}}, Ptr{Ptr{Cdouble}}, Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}), expr, constant, nlinexprs, linexprs, lincoefs, nquadexprs, nbilinexprs, eigenvalues, eigenvectors) -end - -function SCIPexprGetQuadraticQuadTerm(quadexpr, termidx, expr, lincoef, sqrcoef, nadjbilin, adjbilin, sqrexpr) - ccall((:SCIPexprGetQuadraticQuadTerm, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cint}}, Ptr{Ptr{SCIP_EXPR}}), quadexpr, termidx, expr, lincoef, sqrcoef, nadjbilin, adjbilin, sqrexpr) -end - -function SCIPexprGetQuadraticBilinTerm(expr, termidx, expr1, expr2, coef, pos2, prodexpr) - ccall((:SCIPexprGetQuadraticBilinTerm, libscip), Cvoid, (Ptr{SCIP_EXPR}, Cint, Ptr{Ptr{SCIP_EXPR}}, Ptr{Ptr{SCIP_EXPR}}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{SCIP_EXPR}}), expr, termidx, expr1, expr2, coef, pos2, prodexpr) + ccall( + (:SCIPexprSetIntegrality, libscip), + Cvoid, + (Ptr{SCIP_EXPR}, SCIP_IMPLINTTYPE), + expr, + integrality, + ) +end + +function SCIPexprGetQuadraticData( + expr, + constant, + nlinexprs, + linexprs, + lincoefs, + nquadexprs, + nbilinexprs, + eigenvalues, + eigenvectors, +) + ccall( + (:SCIPexprGetQuadraticData, libscip), + Cvoid, + ( + Ptr{SCIP_EXPR}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Ptr{Ptr{SCIP_EXPR}}}, + Ptr{Ptr{Cdouble}}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cdouble}}, + Ptr{Ptr{Cdouble}}, + ), + expr, + constant, + nlinexprs, + linexprs, + lincoefs, + nquadexprs, + nbilinexprs, + eigenvalues, + eigenvectors, + ) +end + +function SCIPexprGetQuadraticQuadTerm( + quadexpr, + termidx, + expr, + lincoef, + sqrcoef, + nadjbilin, + adjbilin, + sqrexpr, +) + ccall( + (:SCIPexprGetQuadraticQuadTerm, libscip), + Cvoid, + ( + Ptr{SCIP_EXPR}, + Cint, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Ptr{Cint}}, + Ptr{Ptr{SCIP_EXPR}}, + ), + quadexpr, + termidx, + expr, + lincoef, + sqrcoef, + nadjbilin, + adjbilin, + sqrexpr, + ) +end + +function SCIPexprGetQuadraticBilinTerm( + expr, + termidx, + expr1, + expr2, + coef, + pos2, + prodexpr, +) + ccall( + (:SCIPexprGetQuadraticBilinTerm, libscip), + Cvoid, + ( + Ptr{SCIP_EXPR}, + Cint, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Ptr{SCIP_EXPR}}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Ptr{SCIP_EXPR}}, + ), + expr, + termidx, + expr1, + expr2, + coef, + pos2, + prodexpr, + ) end function SCIPexprAreQuadraticExprsVariables(expr) - ccall((:SCIPexprAreQuadraticExprsVariables, libscip), Cuint, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPexprAreQuadraticExprsVariables, libscip), + Cuint, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPgetVarExprVar(expr) @@ -18748,7 +55716,12 @@ function SCIPgetValueExprValue(expr) end function SCIPgetCoefsExprSum(expr) - ccall((:SCIPgetCoefsExprSum, libscip), Ptr{Cdouble}, (Ptr{SCIP_EXPR},), expr) + ccall( + (:SCIPgetCoefsExprSum, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_EXPR},), + expr, + ) end function SCIPgetConstantExprSum(expr) @@ -18764,71 +55737,166 @@ function SCIPgetExponentExprPow(expr) end function SCIPexpriterIsInit(iterator) - ccall((:SCIPexpriterIsInit, libscip), Cuint, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterIsInit, libscip), + Cuint, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterInit(iterator, expr, type, allowrevisit) - ccall((:SCIPexpriterInit, libscip), SCIP_RETCODE, (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_TYPE, Cuint), iterator, expr, type, allowrevisit) + ccall( + (:SCIPexpriterInit, libscip), + SCIP_RETCODE, + (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_TYPE, Cuint), + iterator, + expr, + type, + allowrevisit, + ) end function SCIPexpriterRestartDFS(iterator, expr) - ccall((:SCIPexpriterRestartDFS, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}), iterator, expr) + ccall( + (:SCIPexpriterRestartDFS, libscip), + Ptr{SCIP_EXPR}, + (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}), + iterator, + expr, + ) end function SCIPexpriterSetStagesDFS(iterator, stopstages) - ccall((:SCIPexpriterSetStagesDFS, libscip), Cvoid, (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_STAGE), iterator, stopstages) + ccall( + (:SCIPexpriterSetStagesDFS, libscip), + Cvoid, + (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_STAGE), + iterator, + stopstages, + ) end function SCIPexpriterGetCurrent(iterator) - ccall((:SCIPexpriterGetCurrent, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterGetCurrent, libscip), + Ptr{SCIP_EXPR}, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterGetStageDFS(iterator) - ccall((:SCIPexpriterGetStageDFS, libscip), SCIP_EXPRITER_STAGE, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterGetStageDFS, libscip), + SCIP_EXPRITER_STAGE, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterGetChildIdxDFS(iterator) - ccall((:SCIPexpriterGetChildIdxDFS, libscip), Cint, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterGetChildIdxDFS, libscip), + Cint, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterGetChildExprDFS(iterator) - ccall((:SCIPexpriterGetChildExprDFS, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterGetChildExprDFS, libscip), + Ptr{SCIP_EXPR}, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterGetParentDFS(iterator) - ccall((:SCIPexpriterGetParentDFS, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterGetParentDFS, libscip), + Ptr{SCIP_EXPR}, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterGetCurrentUserData(iterator) - ccall((:SCIPexpriterGetCurrentUserData, libscip), SCIP_EXPRITER_USERDATA, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterGetCurrentUserData, libscip), + SCIP_EXPRITER_USERDATA, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterGetChildUserDataDFS(iterator) - ccall((:SCIPexpriterGetChildUserDataDFS, libscip), SCIP_EXPRITER_USERDATA, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterGetChildUserDataDFS, libscip), + SCIP_EXPRITER_USERDATA, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterGetExprUserData(iterator, expr) - ccall((:SCIPexpriterGetExprUserData, libscip), SCIP_EXPRITER_USERDATA, (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}), iterator, expr) + ccall( + (:SCIPexpriterGetExprUserData, libscip), + SCIP_EXPRITER_USERDATA, + (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}), + iterator, + expr, + ) end function SCIPexpriterSetCurrentUserData(iterator, userdata) - ccall((:SCIPexpriterSetCurrentUserData, libscip), Cvoid, (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_USERDATA), iterator, userdata) + ccall( + (:SCIPexpriterSetCurrentUserData, libscip), + Cvoid, + (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_USERDATA), + iterator, + userdata, + ) end function SCIPexpriterSetExprUserData(iterator, expr, userdata) - ccall((:SCIPexpriterSetExprUserData, libscip), Cvoid, (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_USERDATA), iterator, expr, userdata) + ccall( + (:SCIPexpriterSetExprUserData, libscip), + Cvoid, + (Ptr{SCIP_EXPRITER}, Ptr{SCIP_EXPR}, SCIP_EXPRITER_USERDATA), + iterator, + expr, + userdata, + ) end function SCIPexpriterSetChildUserData(iterator, userdata) - ccall((:SCIPexpriterSetChildUserData, libscip), Cvoid, (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_USERDATA), iterator, userdata) + ccall( + (:SCIPexpriterSetChildUserData, libscip), + Cvoid, + (Ptr{SCIP_EXPRITER}, SCIP_EXPRITER_USERDATA), + iterator, + userdata, + ) end function SCIPexpriterGetNext(iterator) - ccall((:SCIPexpriterGetNext, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterGetNext, libscip), + Ptr{SCIP_EXPR}, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterSkipDFS(iterator) - ccall((:SCIPexpriterSkipDFS, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_EXPRITER},), iterator) + ccall( + (:SCIPexpriterSkipDFS, libscip), + Ptr{SCIP_EXPR}, + (Ptr{SCIP_EXPRITER},), + iterator, + ) end function SCIPexpriterIsEnd(iterator) @@ -18836,31 +55904,98 @@ function SCIPexpriterIsEnd(iterator) end function SCIPexprcurvAdd(curv1, curv2) - ccall((:SCIPexprcurvAdd, libscip), SCIP_EXPRCURV, (SCIP_EXPRCURV, SCIP_EXPRCURV), curv1, curv2) + ccall( + (:SCIPexprcurvAdd, libscip), + SCIP_EXPRCURV, + (SCIP_EXPRCURV, SCIP_EXPRCURV), + curv1, + curv2, + ) end function SCIPexprcurvNegate(curvature) - ccall((:SCIPexprcurvNegate, libscip), SCIP_EXPRCURV, (SCIP_EXPRCURV,), curvature) + ccall( + (:SCIPexprcurvNegate, libscip), + SCIP_EXPRCURV, + (SCIP_EXPRCURV,), + curvature, + ) end function SCIPexprcurvMultiply(factor, curvature) - ccall((:SCIPexprcurvMultiply, libscip), SCIP_EXPRCURV, (Cdouble, SCIP_EXPRCURV), factor, curvature) + ccall( + (:SCIPexprcurvMultiply, libscip), + SCIP_EXPRCURV, + (Cdouble, SCIP_EXPRCURV), + factor, + curvature, + ) end function SCIPexprcurvPower(basebounds, basecurv, exponent) - ccall((:SCIPexprcurvPower, libscip), SCIP_EXPRCURV, (SCIP_INTERVAL, SCIP_EXPRCURV, Cdouble), basebounds, basecurv, exponent) + ccall( + (:SCIPexprcurvPower, libscip), + SCIP_EXPRCURV, + (SCIP_INTERVAL, SCIP_EXPRCURV, Cdouble), + basebounds, + basecurv, + exponent, + ) end function SCIPexprcurvPowerInv(basebounds, exponent, powercurv) - ccall((:SCIPexprcurvPowerInv, libscip), SCIP_EXPRCURV, (SCIP_INTERVAL, Cdouble, SCIP_EXPRCURV), basebounds, exponent, powercurv) -end - -function SCIPexprcurvMonomial(nfactors, exponents, factoridxs, factorcurv, factorbounds) - ccall((:SCIPexprcurvMonomial, libscip), SCIP_EXPRCURV, (Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{SCIP_EXPRCURV}, Ptr{SCIP_INTERVAL}), nfactors, exponents, factoridxs, factorcurv, factorbounds) -end - -function SCIPexprcurvMonomialInv(monomialcurv, nfactors, exponents, factorbounds, factorcurv) - ccall((:SCIPexprcurvMonomialInv, libscip), Cuint, (SCIP_EXPRCURV, Cint, Ptr{Cdouble}, Ptr{SCIP_INTERVAL}, Ptr{SCIP_EXPRCURV}), monomialcurv, nfactors, exponents, factorbounds, factorcurv) + ccall( + (:SCIPexprcurvPowerInv, libscip), + SCIP_EXPRCURV, + (SCIP_INTERVAL, Cdouble, SCIP_EXPRCURV), + basebounds, + exponent, + powercurv, + ) +end + +function SCIPexprcurvMonomial( + nfactors, + exponents, + factoridxs, + factorcurv, + factorbounds, +) + ccall( + (:SCIPexprcurvMonomial, libscip), + SCIP_EXPRCURV, + (Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{SCIP_EXPRCURV}, Ptr{SCIP_INTERVAL}), + nfactors, + exponents, + factoridxs, + factorcurv, + factorbounds, + ) +end + +function SCIPexprcurvMonomialInv( + monomialcurv, + nfactors, + exponents, + factorbounds, + factorcurv, +) + ccall( + (:SCIPexprcurvMonomialInv, libscip), + Cuint, + ( + SCIP_EXPRCURV, + Cint, + Ptr{Cdouble}, + Ptr{SCIP_INTERVAL}, + Ptr{SCIP_EXPRCURV}, + ), + monomialcurv, + nfactors, + exponents, + factorbounds, + factorcurv, + ) end function SCIPexprcurvGetName(curv) @@ -18872,19 +56007,47 @@ const SCIP_File = Cvoid const SCIP_FILE = SCIP_File function SCIPfopen(path, mode) - ccall((:SCIPfopen, libscip), Ptr{SCIP_FILE}, (Ptr{Cchar}, Ptr{Cchar}), path, mode) + ccall( + (:SCIPfopen, libscip), + Ptr{SCIP_FILE}, + (Ptr{Cchar}, Ptr{Cchar}), + path, + mode, + ) end function SCIPfdopen(fildes, mode) - ccall((:SCIPfdopen, libscip), Ptr{SCIP_FILE}, (Cint, Ptr{Cchar}), fildes, mode) + ccall( + (:SCIPfdopen, libscip), + Ptr{SCIP_FILE}, + (Cint, Ptr{Cchar}), + 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) + 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) + ccall( + (:SCIPfwrite, libscip), + Csize_t, + (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{SCIP_FILE}), + ptr, + size, + nmemb, + stream, + ) end function SCIPfputc(c, stream) @@ -18900,7 +56063,14 @@ function SCIPfgetc(stream) end function SCIPfgets(s, size, stream) - ccall((:SCIPfgets, libscip), Ptr{Cchar}, (Ptr{Cchar}, Cint, Ptr{SCIP_FILE}), s, size, stream) + ccall( + (:SCIPfgets, libscip), + Ptr{Cchar}, + (Ptr{Cchar}, Cint, Ptr{SCIP_FILE}), + s, + size, + stream, + ) end function SCIPfflush(stream) @@ -18908,7 +56078,14 @@ function SCIPfflush(stream) end function SCIPfseek(stream, offset, whence) - ccall((:SCIPfseek, libscip), Cint, (Ptr{SCIP_FILE}, Clong, Cint), stream, offset, whence) + ccall( + (:SCIPfseek, libscip), + Cint, + (Ptr{SCIP_FILE}, Clong, Cint), + stream, + offset, + whence, + ) end function SCIPrewind(stream) @@ -18928,23 +56105,52 @@ function SCIPfclose(fp) end function SCIPheurComp(elem1, elem2) - ccall((:SCIPheurComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIPheurComp, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPheurCompPriority(elem1, elem2) - ccall((:SCIPheurCompPriority, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIPheurCompPriority, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPheurCompName(elem1, elem2) - ccall((:SCIPheurCompName, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + 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) + ccall( + (:SCIPheurSetData, libscip), + Cvoid, + (Ptr{SCIP_HEUR}, Ptr{SCIP_HEURDATA}), + heur, + heurdata, + ) end function SCIPheurMarkExact(heur) @@ -18964,11 +56170,22 @@ function SCIPheurGetDispchar(heur) end function SCIPheurGetTimingmask(heur) - ccall((:SCIPheurGetTimingmask, libscip), SCIP_HEURTIMING, (Ptr{SCIP_HEUR},), 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) + ccall( + (:SCIPheurSetTimingmask, libscip), + Cvoid, + (Ptr{SCIP_HEUR}, SCIP_HEURTIMING), + heur, + timingmask, + ) end function SCIPheurUsesSubscip(heur) @@ -18984,7 +56201,13 @@ function SCIPheurGetFreq(heur) end function SCIPheurSetFreq(heur, freq) - ccall((:SCIPheurSetFreq, libscip), Cvoid, (Ptr{SCIP_HEUR}, Cint), heur, freq) + ccall( + (:SCIPheurSetFreq, libscip), + Cvoid, + (Ptr{SCIP_HEUR}, Cint), + heur, + freq, + ) end function SCIPheurGetFreqofs(heur) @@ -19004,7 +56227,12 @@ function SCIPheurGetNSolsFound(heur) end function SCIPheurGetNBestSolsFound(heur) - ccall((:SCIPheurGetNBestSolsFound, libscip), Clonglong, (Ptr{SCIP_HEUR},), heur) + ccall( + (:SCIPheurGetNBestSolsFound, libscip), + Clonglong, + (Ptr{SCIP_HEUR},), + heur, + ) end function SCIPheurIsInitialized(heur) @@ -19020,7 +56248,12 @@ function SCIPheurGetTime(heur) end function SCIPheurGetDivesets(heur) - ccall((:SCIPheurGetDivesets, libscip), Ptr{Ptr{SCIP_DIVESET}}, (Ptr{SCIP_HEUR},), heur) + ccall( + (:SCIPheurGetDivesets, libscip), + Ptr{Ptr{SCIP_DIVESET}}, + (Ptr{SCIP_HEUR},), + heur, + ) end function SCIPheurGetNDivesets(heur) @@ -19028,203 +56261,506 @@ function SCIPheurGetNDivesets(heur) end function SCIPdivesetGetHeur(diveset) - ccall((:SCIPdivesetGetHeur, libscip), Ptr{SCIP_HEUR}, (Ptr{SCIP_DIVESET},), 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) + 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) + ccall( + (:SCIPdivesetSetWorkSolution, libscip), + Cvoid, + (Ptr{SCIP_DIVESET}, Ptr{SCIP_SOL}), + diveset, + sol, + ) end function SCIPdivesetGetName(diveset) - ccall((:SCIPdivesetGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetMinRelDepth(diveset) - ccall((:SCIPdivesetGetMinRelDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetMinRelDepth, libscip), + Cdouble, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetMaxRelDepth(diveset) - ccall((:SCIPdivesetGetMaxRelDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetMaxRelDepth, libscip), + Cdouble, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetSolSuccess(diveset, divecontext) - ccall((:SCIPdivesetGetSolSuccess, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetSolSuccess, libscip), + Clonglong, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetNCalls(diveset, divecontext) - ccall((:SCIPdivesetGetNCalls, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetNCalls, libscip), + Cint, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetNSolutionCalls(diveset, divecontext) - ccall((:SCIPdivesetGetNSolutionCalls, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetNSolutionCalls, libscip), + Cint, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetMinDepth(diveset, divecontext) - ccall((:SCIPdivesetGetMinDepth, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetMinDepth, libscip), + Cint, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetMaxDepth(diveset, divecontext) - ccall((:SCIPdivesetGetMaxDepth, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetMaxDepth, libscip), + Cint, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetAvgDepth(diveset, divecontext) - ccall((:SCIPdivesetGetAvgDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetAvgDepth, libscip), + Cdouble, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetMinSolutionDepth(diveset, divecontext) - ccall((:SCIPdivesetGetMinSolutionDepth, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetMinSolutionDepth, libscip), + Cint, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetMaxSolutionDepth(diveset, divecontext) - ccall((:SCIPdivesetGetMaxSolutionDepth, libscip), Cint, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetMaxSolutionDepth, libscip), + Cint, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetAvgSolutionDepth(diveset, divecontext) - ccall((:SCIPdivesetGetAvgSolutionDepth, libscip), Cdouble, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetAvgSolutionDepth, libscip), + Cdouble, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetNLPIterations(diveset, divecontext) - ccall((:SCIPdivesetGetNLPIterations, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetNLPIterations, libscip), + Clonglong, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetNProbingNodes(diveset, divecontext) - ccall((:SCIPdivesetGetNProbingNodes, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetNProbingNodes, libscip), + Clonglong, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetNBacktracks(diveset, divecontext) - ccall((:SCIPdivesetGetNBacktracks, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetNBacktracks, libscip), + Clonglong, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetNConflicts(diveset, divecontext) - ccall((:SCIPdivesetGetNConflicts, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetNConflicts, libscip), + Clonglong, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetNSols(diveset, divecontext) - ccall((:SCIPdivesetGetNSols, libscip), Clonglong, (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), diveset, divecontext) + ccall( + (:SCIPdivesetGetNSols, libscip), + Clonglong, + (Ptr{SCIP_DIVESET}, SCIP_DIVECONTEXT), + diveset, + divecontext, + ) end function SCIPdivesetGetMaxLPIterQuot(diveset) - ccall((:SCIPdivesetGetMaxLPIterQuot, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetMaxLPIterQuot, libscip), + Cdouble, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetMaxLPIterOffset(diveset) - ccall((:SCIPdivesetGetMaxLPIterOffset, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetMaxLPIterOffset, libscip), + Cint, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetUbQuotNoSol(diveset) - ccall((:SCIPdivesetGetUbQuotNoSol, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetUbQuotNoSol, libscip), + Cdouble, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetAvgQuotNoSol(diveset) - ccall((:SCIPdivesetGetAvgQuotNoSol, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetAvgQuotNoSol, libscip), + Cdouble, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetUbQuot(diveset) - ccall((:SCIPdivesetGetUbQuot, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetUbQuot, libscip), + Cdouble, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetAvgQuot(diveset) - ccall((:SCIPdivesetGetAvgQuot, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetAvgQuot, libscip), + Cdouble, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetUseBacktrack(diveset) - ccall((:SCIPdivesetUseBacktrack, libscip), Cuint, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetUseBacktrack, libscip), + Cuint, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetLPSolveFreq(diveset) - ccall((:SCIPdivesetGetLPSolveFreq, libscip), Cint, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetLPSolveFreq, libscip), + Cint, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetGetLPResolveDomChgQuot(diveset) - ccall((:SCIPdivesetGetLPResolveDomChgQuot, libscip), Cdouble, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetLPResolveDomChgQuot, libscip), + Cdouble, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetUseOnlyLPBranchcands(diveset) - ccall((:SCIPdivesetUseOnlyLPBranchcands, libscip), Cuint, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetUseOnlyLPBranchcands, libscip), + Cuint, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetSupportsType(diveset, divetype) - ccall((:SCIPdivesetSupportsType, libscip), Cuint, (Ptr{SCIP_DIVESET}, SCIP_DIVETYPE), diveset, divetype) + ccall( + (:SCIPdivesetSupportsType, libscip), + Cuint, + (Ptr{SCIP_DIVESET}, SCIP_DIVETYPE), + diveset, + divetype, + ) end function SCIPdivesetGetRandnumgen(diveset) - ccall((:SCIPdivesetGetRandnumgen, libscip), Ptr{SCIP_RANDNUMGEN}, (Ptr{SCIP_DIVESET},), diveset) + ccall( + (:SCIPdivesetGetRandnumgen, libscip), + Ptr{SCIP_RANDNUMGEN}, + (Ptr{SCIP_DIVESET},), + diveset, + ) end function SCIPdivesetIsPublic(diveset) ccall((:SCIPdivesetIsPublic, libscip), Cuint, (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}}, Cuint, Cdouble, Ptr{Cint}), scip, vargraph, relaxdenseconss, relaxdensity, nrelaxedconstraints) +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}}, Cuint, 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) + ccall( + (:SCIPvariableGraphFree, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{SCIP_VGRAPH}}), + scip, + vargraph, + ) end function SCIPhistoryGetVSIDS(history, dir) - ccall((:SCIPhistoryGetVSIDS, libscip), Cdouble, (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), history, dir) + ccall( + (:SCIPhistoryGetVSIDS, libscip), + Cdouble, + (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), + history, + dir, + ) end function SCIPhistoryGetAvgConflictlength(history, dir) - ccall((:SCIPhistoryGetAvgConflictlength, libscip), Cdouble, (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), history, dir) + ccall( + (:SCIPhistoryGetAvgConflictlength, 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) + ccall( + (:SCIPhistoryGetCutoffSum, libscip), + Cdouble, + (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), + history, + dir, + ) end function SCIPhistoryGetInferenceSum(history, dir) - ccall((:SCIPhistoryGetInferenceSum, libscip), Cdouble, (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), history, dir) + ccall( + (:SCIPhistoryGetInferenceSum, libscip), + Cdouble, + (Ptr{SCIP_HISTORY}, SCIP_BRANCHDIR), + history, + dir, + ) end function SCIPvaluehistoryGetNValues(valuehistory) - ccall((:SCIPvaluehistoryGetNValues, libscip), Cint, (Ptr{SCIP_VALUEHISTORY},), valuehistory) + ccall( + (:SCIPvaluehistoryGetNValues, libscip), + Cint, + (Ptr{SCIP_VALUEHISTORY},), + valuehistory, + ) end function SCIPvaluehistoryGetHistories(valuehistory) - ccall((:SCIPvaluehistoryGetHistories, libscip), Ptr{Ptr{SCIP_HISTORY}}, (Ptr{SCIP_VALUEHISTORY},), 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) + ccall( + (:SCIPvaluehistoryGetValues, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_VALUEHISTORY},), + valuehistory, + ) end function SCIPiisfinderGetName(iisfinder) - ccall((:SCIPiisfinderGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_IISFINDER},), iisfinder) + ccall( + (:SCIPiisfinderGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_IISFINDER},), + iisfinder, + ) end function SCIPiisfinderGetData(iisfinder) - ccall((:SCIPiisfinderGetData, libscip), Ptr{SCIP_IISFINDERDATA}, (Ptr{SCIP_IISFINDER},), iisfinder) + ccall( + (:SCIPiisfinderGetData, libscip), + Ptr{SCIP_IISFINDERDATA}, + (Ptr{SCIP_IISFINDER},), + iisfinder, + ) end function SCIPiisfinderGetDesc(iisfinder) - ccall((:SCIPiisfinderGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_IISFINDER},), iisfinder) + ccall( + (:SCIPiisfinderGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_IISFINDER},), + iisfinder, + ) end function SCIPiisfinderGetPriority(iisfinder) - ccall((:SCIPiisfinderGetPriority, libscip), Cint, (Ptr{SCIP_IISFINDER},), iisfinder) + ccall( + (:SCIPiisfinderGetPriority, libscip), + Cint, + (Ptr{SCIP_IISFINDER},), + iisfinder, + ) end function SCIPiisfinderSetData(iisfinder, iisfinderdata) - ccall((:SCIPiisfinderSetData, libscip), Cvoid, (Ptr{SCIP_IISFINDER}, Ptr{SCIP_IISFINDERDATA}), iisfinder, iisfinderdata) + ccall( + (:SCIPiisfinderSetData, libscip), + Cvoid, + (Ptr{SCIP_IISFINDER}, Ptr{SCIP_IISFINDERDATA}), + iisfinder, + iisfinderdata, + ) end function SCIPiisfinderGetTime(iisfinder) - ccall((:SCIPiisfinderGetTime, libscip), Cdouble, (Ptr{SCIP_IISFINDER},), iisfinder) + ccall( + (:SCIPiisfinderGetTime, libscip), + Cdouble, + (Ptr{SCIP_IISFINDER},), + iisfinder, + ) end function SCIPiisfinderInfoMessage(iis, printheaders) - ccall((:SCIPiisfinderInfoMessage, libscip), Cvoid, (Ptr{SCIP_IIS}, Cuint), iis, printheaders) + ccall( + (:SCIPiisfinderInfoMessage, libscip), + Cvoid, + (Ptr{SCIP_IIS}, Cuint), + iis, + printheaders, + ) end function SCIPiisGetTime(iis) @@ -19244,19 +56780,42 @@ function SCIPiisGetNNodes(iis) end function SCIPiisSetSubscipInfeasible(iis, infeasible) - ccall((:SCIPiisSetSubscipInfeasible, libscip), Cvoid, (Ptr{SCIP_IIS}, Cuint), iis, infeasible) + ccall( + (:SCIPiisSetSubscipInfeasible, libscip), + Cvoid, + (Ptr{SCIP_IIS}, Cuint), + iis, + infeasible, + ) end function SCIPiisSetSubscipIrreducible(iis, irreducible) - ccall((:SCIPiisSetSubscipIrreducible, libscip), Cvoid, (Ptr{SCIP_IIS}, Cuint), iis, irreducible) + ccall( + (:SCIPiisSetSubscipIrreducible, libscip), + Cvoid, + (Ptr{SCIP_IIS}, Cuint), + iis, + irreducible, + ) end function SCIPiisAddNNodes(iis, nnodes) - ccall((:SCIPiisAddNNodes, libscip), Cvoid, (Ptr{SCIP_IIS}, Clonglong), iis, nnodes) + ccall( + (:SCIPiisAddNNodes, libscip), + Cvoid, + (Ptr{SCIP_IIS}, Clonglong), + iis, + nnodes, + ) end function SCIPiisGetRandnumgen(iis) - ccall((:SCIPiisGetRandnumgen, libscip), Ptr{SCIP_RANDNUMGEN}, (Ptr{SCIP_IIS},), iis) + ccall( + (:SCIPiisGetRandnumgen, libscip), + Ptr{SCIP_RANDNUMGEN}, + (Ptr{SCIP_IIS},), + iis, + ) end function SCIPiisGetSubscip(iis) @@ -19264,15 +56823,35 @@ function SCIPiisGetSubscip(iis) end function SCIPiisfinderComp(elem1, elem2) - ccall((:SCIPiisfinderComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIPiisfinderComp, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPcliqueSearchVar(clique, var, value) - ccall((:SCIPcliqueSearchVar, libscip), Cint, (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, Cuint), clique, var, value) + ccall( + (:SCIPcliqueSearchVar, libscip), + Cint, + (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, Cuint), + clique, + var, + value, + ) end function SCIPcliqueHasVar(clique, var, value) - ccall((:SCIPcliqueHasVar, libscip), Cuint, (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, Cuint), clique, var, value) + ccall( + (:SCIPcliqueHasVar, libscip), + Cuint, + (Ptr{SCIP_CLIQUE}, Ptr{SCIP_VAR}, Cuint), + clique, + var, + value, + ) end function SCIPcliqueGetNVars(clique) @@ -19280,11 +56859,21 @@ function SCIPcliqueGetNVars(clique) end function SCIPcliqueGetVars(clique) - ccall((:SCIPcliqueGetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_CLIQUE},), clique) + ccall( + (:SCIPcliqueGetVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_CLIQUE},), + clique, + ) end function SCIPcliqueGetValues(clique) - ccall((:SCIPcliqueGetValues, libscip), Ptr{Cuint}, (Ptr{SCIP_CLIQUE},), clique) + ccall( + (:SCIPcliqueGetValues, libscip), + Ptr{Cuint}, + (Ptr{SCIP_CLIQUE},), + clique, + ) end function SCIPcliqueGetId(clique) @@ -19345,7 +56934,12 @@ end const SCIP_BASESTAT = SCIP_BaseStat function SCIPcolGetBasisStatus(col) - ccall((:SCIPcolGetBasisStatus, libscip), SCIP_BASESTAT, (Ptr{SCIP_COL},), col) + ccall( + (:SCIPcolGetBasisStatus, libscip), + SCIP_BASESTAT, + (Ptr{SCIP_COL},), + col, + ) end function SCIPcolGetVar(col) @@ -19401,7 +56995,12 @@ function SCIPcolGetVals(col) end function SCIPcolGetStrongbranchNode(col) - ccall((:SCIPcolGetStrongbranchNode, libscip), Clonglong, (Ptr{SCIP_COL},), col) + ccall( + (:SCIPcolGetStrongbranchNode, libscip), + Clonglong, + (Ptr{SCIP_COL},), + col, + ) end function SCIPcolGetNStrongbranchs(col) @@ -19413,7 +57012,12 @@ function SCIPcolGetAge(col) end function SCIPboundtypeOpposite(boundtype) - ccall((:SCIPboundtypeOpposite, libscip), SCIP_BOUNDTYPE, (SCIP_BOUNDTYPE,), boundtype) + ccall( + (:SCIPboundtypeOpposite, libscip), + SCIP_BOUNDTYPE, + (SCIP_BOUNDTYPE,), + boundtype, + ) end function SCIProwComp(elem1, elem2) @@ -19429,15 +57033,35 @@ function SCIProwUnlock(row) end function SCIProwGetScalarProduct(row1, row2) - ccall((:SCIProwGetScalarProduct, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}), 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}, Cchar), row1, row2, orthofunc) + ccall( + (:SCIProwGetParallelism, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Cchar), + row1, + row2, + orthofunc, + ) end function SCIProwGetOrthogonality(row1, row2, orthofunc) - ccall((:SCIProwGetOrthogonality, libscip), Cdouble, (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Cchar), row1, row2, orthofunc) + ccall( + (:SCIProwGetOrthogonality, libscip), + Cdouble, + (Ptr{SCIP_ROW}, Ptr{SCIP_ROW}, Cchar), + row1, + row2, + orthofunc, + ) end function SCIProwSort(row) @@ -19489,7 +57113,12 @@ function SCIProwGetDualfarkas(row) end function SCIProwGetBasisStatus(row) - ccall((:SCIProwGetBasisStatus, libscip), SCIP_BASESTAT, (Ptr{SCIP_ROW},), row) + ccall( + (:SCIProwGetBasisStatus, libscip), + SCIP_BASESTAT, + (Ptr{SCIP_ROW},), + row, + ) end function SCIProwGetName(row) @@ -19525,19 +57154,39 @@ function SCIProwIsRemovable(row) end function SCIProwGetOrigintype(row) - ccall((:SCIProwGetOrigintype, libscip), SCIP_ROWORIGINTYPE, (Ptr{SCIP_ROW},), row) + ccall( + (:SCIProwGetOrigintype, libscip), + SCIP_ROWORIGINTYPE, + (Ptr{SCIP_ROW},), + row, + ) end function SCIProwGetOriginConshdlr(row) - ccall((:SCIProwGetOriginConshdlr, libscip), Ptr{SCIP_CONSHDLR}, (Ptr{SCIP_ROW},), row) + ccall( + (:SCIProwGetOriginConshdlr, libscip), + Ptr{SCIP_CONSHDLR}, + (Ptr{SCIP_ROW},), + row, + ) end function SCIProwGetOriginCons(row) - ccall((:SCIProwGetOriginCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_ROW},), row) + ccall( + (:SCIProwGetOriginCons, libscip), + Ptr{SCIP_CONS}, + (Ptr{SCIP_ROW},), + row, + ) end function SCIProwGetOriginSepa(row) - ccall((:SCIProwGetOriginSepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP_ROW},), row) + ccall( + (:SCIProwGetOriginSepa, libscip), + Ptr{SCIP_SEPA}, + (Ptr{SCIP_ROW},), + row, + ) end function SCIProwIsInGlobalCutpool(row) @@ -19561,7 +57210,12 @@ function SCIProwGetActiveLPCount(row) end function SCIProwGetNLPsAfterCreation(row) - ccall((:SCIProwGetNLPsAfterCreation, libscip), Clonglong, (Ptr{SCIP_ROW},), row) + ccall( + (:SCIProwGetNLPsAfterCreation, libscip), + Clonglong, + (Ptr{SCIP_ROW},), + row, + ) end function SCIProwChgRank(row, rank) @@ -19569,27 +57223,58 @@ function SCIProwChgRank(row, rank) end function SCIProwGetRowExact(row) - ccall((:SCIProwGetRowExact, libscip), Ptr{SCIP_ROWEXACT}, (Ptr{SCIP_ROW},), row) + ccall( + (:SCIProwGetRowExact, libscip), + Ptr{SCIP_ROWEXACT}, + (Ptr{SCIP_ROW},), + row, + ) end function SCIProwExactComp(elem1, elem2) - ccall((:SCIProwExactComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIProwExactComp, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPcolExactGetVar(col) - ccall((:SCIPcolExactGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_COLEXACT},), col) + ccall( + (:SCIPcolExactGetVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_COLEXACT},), + col, + ) end function SCIProwExactGetLhs(row) - ccall((:SCIProwExactGetLhs, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT},), row) + ccall( + (:SCIProwExactGetLhs, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_ROWEXACT},), + row, + ) end function SCIProwExactGetRhs(row) - ccall((:SCIProwExactGetRhs, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT},), row) + ccall( + (:SCIProwExactGetRhs, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_ROWEXACT},), + row, + ) end function SCIProwExactGetConstant(row) - ccall((:SCIProwExactGetConstant, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_ROWEXACT},), row) + ccall( + (:SCIProwExactGetConstant, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_ROWEXACT},), + row, + ) end function SCIProwExactGetNNonz(row) @@ -19597,7 +57282,12 @@ function SCIProwExactGetNNonz(row) end function SCIProwExactGetVals(row) - ccall((:SCIProwExactGetVals, libscip), Ptr{Ptr{SCIP_RATIONAL}}, (Ptr{SCIP_ROWEXACT},), row) + ccall( + (:SCIProwExactGetVals, libscip), + Ptr{Ptr{SCIP_RATIONAL}}, + (Ptr{SCIP_ROWEXACT},), + row, + ) end function SCIProwExactIsInLP(row) @@ -19609,7 +57299,12 @@ function SCIProwExactSort(row) end function SCIProwExactGetCols(row) - ccall((:SCIProwExactGetCols, libscip), Ptr{Ptr{SCIP_COLEXACT}}, (Ptr{SCIP_ROWEXACT},), row) + ccall( + (:SCIProwExactGetCols, libscip), + Ptr{Ptr{SCIP_COLEXACT}}, + (Ptr{SCIP_ROWEXACT},), + row, + ) end function SCIProwExactLock(row) @@ -19621,11 +57316,21 @@ function SCIProwExactUnlock(row) end function SCIProwExactGetRow(row) - ccall((:SCIProwExactGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_ROWEXACT},), row) + ccall( + (:SCIProwExactGetRow, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP_ROWEXACT},), + row, + ) end function SCIProwExactGetRowRhs(row) - ccall((:SCIProwExactGetRowRhs, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP_ROWEXACT},), row) + ccall( + (:SCIProwExactGetRowRhs, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP_ROWEXACT},), + row, + ) end function SCIProwExactHasFpRelax(row) @@ -19637,15 +57342,33 @@ function SCIPlpExactDiving(lpexact) end function SCIPmatrixGetColValPtr(matrix, col) - ccall((:SCIPmatrixGetColValPtr, libscip), Ptr{Cdouble}, (Ptr{SCIP_MATRIX}, Cint), 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) + 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) + ccall( + (:SCIPmatrixGetColNNonzs, libscip), + Cint, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + col, + ) end function SCIPmatrixGetNColumns(matrix) @@ -19653,47 +57376,113 @@ function SCIPmatrixGetNColumns(matrix) end function SCIPmatrixGetColUb(matrix, col) - ccall((:SCIPmatrixGetColUb, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), 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) + 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) + 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) + 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) + ccall( + (:SCIPmatrixGetVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + col, + ) end function SCIPmatrixGetColName(matrix, col) - ccall((:SCIPmatrixGetColName, libscip), Ptr{Cchar}, (Ptr{SCIP_MATRIX}, Cint), matrix, col) + ccall( + (:SCIPmatrixGetColName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + col, + ) end function SCIPmatrixGetRowValPtr(matrix, row) - ccall((:SCIPmatrixGetRowValPtr, libscip), Ptr{Cdouble}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) + ccall( + (:SCIPmatrixGetRowValPtr, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixGetRowValPtrExact(matrix, row) - ccall((:SCIPmatrixGetRowValPtrExact, libscip), Ptr{Ptr{SCIP_RATIONAL}}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) + ccall( + (:SCIPmatrixGetRowValPtrExact, libscip), + Ptr{Ptr{SCIP_RATIONAL}}, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixGetRowIdxPtr(matrix, row) - ccall((:SCIPmatrixGetRowIdxPtr, libscip), Ptr{Cint}, (Ptr{SCIP_MATRIX}, Cint), 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) + ccall( + (:SCIPmatrixGetRowNNonzs, libscip), + Cint, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixGetRowName(matrix, row) - ccall((:SCIPmatrixGetRowName, libscip), Ptr{Cchar}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) + ccall( + (:SCIPmatrixGetRowName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixGetNRows(matrix) @@ -19701,23 +57490,53 @@ function SCIPmatrixGetNRows(matrix) end function SCIPmatrixGetRowLhs(matrix, row) - ccall((:SCIPmatrixGetRowLhs, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), 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) + ccall( + (:SCIPmatrixGetRowRhs, libscip), + Cdouble, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixGetRowLhsExact(matrix, row) - ccall((:SCIPmatrixGetRowLhsExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) + ccall( + (:SCIPmatrixGetRowLhsExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixGetRowRhsExact(matrix, row) - ccall((:SCIPmatrixGetRowRhsExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_MATRIX}, Cint), matrix, row) + ccall( + (:SCIPmatrixGetRowRhsExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixIsRowRhsInfinity(matrix, row) - ccall((:SCIPmatrixIsRowRhsInfinity, libscip), Cuint, (Ptr{SCIP_MATRIX}, Cint), matrix, row) + ccall( + (:SCIPmatrixIsRowRhsInfinity, libscip), + Cuint, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixGetNNonzs(matrix) @@ -19725,91 +57544,288 @@ function SCIPmatrixGetNNonzs(matrix) end function SCIPmatrixGetRowMinActivity(matrix, row) - ccall((:SCIPmatrixGetRowMinActivity, libscip), Cdouble, (Ptr{SCIP_MATRIX}, Cint), 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPmatrixGetCons, libscip), + Ptr{SCIP_CONS}, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + row, + ) end function SCIPmatrixUplockConflict(matrix, col) - ccall((:SCIPmatrixUplockConflict, libscip), Cuint, (Ptr{SCIP_MATRIX}, Cint), matrix, col) + ccall( + (:SCIPmatrixUplockConflict, libscip), + Cuint, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + col, + ) end function SCIPmatrixDownlockConflict(matrix, col) - ccall((:SCIPmatrixDownlockConflict, libscip), Cuint, (Ptr{SCIP_MATRIX}, Cint), matrix, col) -end - -function SCIPmatrixCreate(scip, matrixptr, onlyifcomplete, initialized, complete, infeasible, naddconss, ndelconss, nchgcoefs, nchgbds, nfixedvars) - ccall((:SCIPmatrixCreate, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_MATRIX}}, Cuint, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), scip, matrixptr, onlyifcomplete, initialized, complete, infeasible, naddconss, ndelconss, nchgcoefs, nchgbds, nfixedvars) + ccall( + (:SCIPmatrixDownlockConflict, libscip), + Cuint, + (Ptr{SCIP_MATRIX}, Cint), + matrix, + col, + ) +end + +function SCIPmatrixCreate( + scip, + matrixptr, + onlyifcomplete, + initialized, + complete, + infeasible, + naddconss, + ndelconss, + nchgcoefs, + nchgbds, + nfixedvars, +) + ccall( + (:SCIPmatrixCreate, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{Ptr{SCIP_MATRIX}}, + Cuint, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + scip, + matrixptr, + onlyifcomplete, + initialized, + complete, + infeasible, + naddconss, + ndelconss, + nchgcoefs, + nchgbds, + nfixedvars, + ) end function SCIPmatrixFree(scip, matrix) - ccall((:SCIPmatrixFree, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_MATRIX}}), 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) + 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) + ccall( + (:SCIPmatrixGetParallelRows, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Ptr{Cdouble}, Ptr{Cint}), + scip, + matrix, + scale, + pclass, + ) end function SCIPmatrixRemoveColumnBounds(scip, matrix, col) - ccall((:SCIPmatrixRemoveColumnBounds, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Cint), scip, matrix, col) + ccall( + (:SCIPmatrixRemoveColumnBounds, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Cint), + scip, + matrix, + col, + ) end function SCIPmatrixGetParallelCols(scip, matrix, scale, pclass, varineq) - ccall((:SCIPmatrixGetParallelCols, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}), scip, matrix, scale, pclass, varineq) -end - -function SCIPmessagehdlrCreate(messagehdlr, bufferedoutput, filename, quiet, messagewarning, messagedialog, messageinfo, messagehdlrfree, messagehdlrdata) - ccall((:SCIPmessagehdlrCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_MESSAGEHDLR}}, Cuint, Ptr{Cchar}, Cuint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{SCIP_MESSAGEHDLRDATA}), messagehdlr, bufferedoutput, filename, quiet, messagewarning, messagedialog, messageinfo, messagehdlrfree, messagehdlrdata) + ccall( + (:SCIPmatrixGetParallelCols, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_MATRIX}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}), + scip, + matrix, + scale, + pclass, + varineq, + ) +end + +function SCIPmessagehdlrCreate( + messagehdlr, + bufferedoutput, + filename, + quiet, + messagewarning, + messagedialog, + messageinfo, + messagehdlrfree, + messagehdlrdata, +) + ccall( + (:SCIPmessagehdlrCreate, libscip), + SCIP_RETCODE, + ( + Ptr{Ptr{SCIP_MESSAGEHDLR}}, + Cuint, + Ptr{Cchar}, + Cuint, + 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) + ccall( + (:SCIPmessagehdlrCapture, libscip), + Cvoid, + (Ptr{SCIP_MESSAGEHDLR},), + messagehdlr, + ) end function SCIPmessagehdlrRelease(messagehdlr) - ccall((:SCIPmessagehdlrRelease, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_MESSAGEHDLR}},), 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) + 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}, Ptr{Cchar}), messagehdlr, filename) + ccall( + (:SCIPmessagehdlrSetLogfile, libscip), + Cvoid, + (Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}), + messagehdlr, + filename, + ) end function SCIPmessagehdlrSetQuiet(messagehdlr, quiet) - ccall((:SCIPmessagehdlrSetQuiet, libscip), Cvoid, (Ptr{SCIP_MESSAGEHDLR}, Cuint), messagehdlr, quiet) + ccall( + (:SCIPmessagehdlrSetQuiet, libscip), + Cvoid, + (Ptr{SCIP_MESSAGEHDLR}, Cuint), + messagehdlr, + quiet, + ) end function SCIPmessageSetErrorPrinting(errorPrinting, data) - ccall((:SCIPmessageSetErrorPrinting, libscip), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}), errorPrinting, data) + ccall( + (:SCIPmessageSetErrorPrinting, libscip), + Cvoid, + (Ptr{Cvoid}, Ptr{Cvoid}), + errorPrinting, + data, + ) end function SCIPmessageSetErrorPrintingDefault() @@ -19817,23 +57833,61 @@ function SCIPmessageSetErrorPrintingDefault() end function SCIPmessagehdlrGetData(messagehdlr) - ccall((:SCIPmessagehdlrGetData, libscip), Ptr{SCIP_MESSAGEHDLRDATA}, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) + ccall( + (:SCIPmessagehdlrGetData, libscip), + Ptr{SCIP_MESSAGEHDLRDATA}, + (Ptr{SCIP_MESSAGEHDLR},), + messagehdlr, + ) end function SCIPmessagehdlrGetLogfile(messagehdlr) - ccall((:SCIPmessagehdlrGetLogfile, libscip), Ptr{Libc.FILE}, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) + ccall( + (:SCIPmessagehdlrGetLogfile, libscip), + Ptr{Libc.FILE}, + (Ptr{SCIP_MESSAGEHDLR},), + messagehdlr, + ) end function SCIPmessagehdlrIsQuiet(messagehdlr) - ccall((:SCIPmessagehdlrIsQuiet, libscip), Cuint, (Ptr{SCIP_MESSAGEHDLR},), messagehdlr) + ccall( + (:SCIPmessagehdlrIsQuiet, libscip), + Cuint, + (Ptr{SCIP_MESSAGEHDLR},), + messagehdlr, + ) end 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) + 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) @@ -19841,63 +57895,180 @@ function SCIPerf(x) end function SCIPnormalGetCriticalValue(clevel) - ccall((:SCIPnormalGetCriticalValue, libscip), Cdouble, (SCIP_CONFIDENCELEVEL,), clevel) + ccall( + (:SCIPnormalGetCriticalValue, libscip), + Cdouble, + (SCIP_CONFIDENCELEVEL,), + clevel, + ) end function SCIPnormalCDF(mean, variance, value) - ccall((:SCIPnormalCDF, libscip), Cdouble, (Cdouble, Cdouble, Cdouble), 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) + ccall( + (:SCIPregressionGetNObservations, libscip), + Cint, + (Ptr{SCIP_REGRESSION},), + regression, + ) end function SCIPregressionGetSlope(regression) - ccall((:SCIPregressionGetSlope, libscip), Cdouble, (Ptr{SCIP_REGRESSION},), regression) + ccall( + (:SCIPregressionGetSlope, libscip), + Cdouble, + (Ptr{SCIP_REGRESSION},), + regression, + ) end function SCIPregressionGetIntercept(regression) - ccall((:SCIPregressionGetIntercept, libscip), Cdouble, (Ptr{SCIP_REGRESSION},), 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) + 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) + ccall( + (:SCIPregressionAddObservation, libscip), + Cvoid, + (Ptr{SCIP_REGRESSION}, Cdouble, Cdouble), + regression, + x, + y, + ) end function SCIPregressionReset(regression) - ccall((:SCIPregressionReset, libscip), Cvoid, (Ptr{SCIP_REGRESSION},), regression) + ccall( + (:SCIPregressionReset, libscip), + Cvoid, + (Ptr{SCIP_REGRESSION},), + regression, + ) end function SCIPregressionCreate(regression) - ccall((:SCIPregressionCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_REGRESSION}},), regression) + ccall( + (:SCIPregressionCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_REGRESSION}},), + regression, + ) end function SCIPregressionFree(regression) - ccall((:SCIPregressionFree, libscip), Cvoid, (Ptr{Ptr{SCIP_REGRESSION}},), regression) + ccall( + (:SCIPregressionFree, libscip), + Cvoid, + (Ptr{Ptr{SCIP_REGRESSION}},), + regression, + ) end function SCIPgmlWriteNode(file, id, label, nodetype, fillcolor, bordercolor) - ccall((:SCIPgmlWriteNode, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}), file, id, label, nodetype, fillcolor, bordercolor) -end - -function SCIPgmlWriteNodeWeight(file, id, label, nodetype, fillcolor, bordercolor, weight) - ccall((:SCIPgmlWriteNodeWeight, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Cdouble), file, id, label, nodetype, fillcolor, bordercolor, weight) + ccall( + (:SCIPgmlWriteNode, libscip), + Cvoid, + (Ptr{Libc.FILE}, Cuint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}), + file, + id, + label, + nodetype, + fillcolor, + bordercolor, + ) +end + +function SCIPgmlWriteNodeWeight( + file, + id, + label, + nodetype, + fillcolor, + bordercolor, + weight, +) + ccall( + (:SCIPgmlWriteNodeWeight, libscip), + Cvoid, + ( + Ptr{Libc.FILE}, + Cuint, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cchar}, + Ptr{Cchar}, + Cdouble, + ), + file, + id, + label, + nodetype, + fillcolor, + bordercolor, + weight, + ) end function SCIPgmlWriteEdge(file, source, target, label, color) - ccall((:SCIPgmlWriteEdge, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint, Cuint, Ptr{Cchar}, Ptr{Cchar}), file, source, target, label, color) + ccall( + (:SCIPgmlWriteEdge, libscip), + Cvoid, + (Ptr{Libc.FILE}, Cuint, Cuint, Ptr{Cchar}, Ptr{Cchar}), + file, + source, + target, + label, + color, + ) end function SCIPgmlWriteArc(file, source, target, label, color) - ccall((:SCIPgmlWriteArc, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint, Cuint, Ptr{Cchar}, Ptr{Cchar}), file, source, target, label, color) + ccall( + (:SCIPgmlWriteArc, libscip), + Cvoid, + (Ptr{Libc.FILE}, Cuint, Cuint, Ptr{Cchar}, Ptr{Cchar}), + file, + source, + target, + label, + color, + ) end function SCIPgmlWriteOpening(file, directed) - ccall((:SCIPgmlWriteOpening, libscip), Cvoid, (Ptr{Libc.FILE}, Cuint), file, directed) + ccall( + (:SCIPgmlWriteOpening, libscip), + Cvoid, + (Ptr{Libc.FILE}, Cuint), + file, + directed, + ) end function SCIPgmlWriteClosing(file) @@ -19909,11 +58080,29 @@ function SCIPdotWriteOpening(file) end function SCIPdotWriteNode(file, node, label, nodetype, fillcolor, bordercolor) - ccall((:SCIPdotWriteNode, libscip), Cvoid, (Ptr{Libc.FILE}, Cint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}), file, node, label, nodetype, fillcolor, bordercolor) + ccall( + (:SCIPdotWriteNode, libscip), + Cvoid, + (Ptr{Libc.FILE}, Cint, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}, Ptr{Cchar}), + file, + node, + label, + nodetype, + fillcolor, + bordercolor, + ) end function SCIPdotWriteArc(file, source, target, color) - ccall((:SCIPdotWriteArc, libscip), Cvoid, (Ptr{Libc.FILE}, Cint, Cint, Ptr{Cchar}), file, source, target, color) + ccall( + (:SCIPdotWriteArc, libscip), + Cvoid, + (Ptr{Libc.FILE}, Cint, Cint, Ptr{Cchar}), + file, + source, + target, + color, + ) end function SCIPdotWriteClosing(file) @@ -19921,39 +58110,93 @@ function SCIPdotWriteClosing(file) end function SCIPsparseSolCreate(sparsesol, vars, nvars, cleared) - ccall((:SCIPsparseSolCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_SPARSESOL}}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint), sparsesol, vars, nvars, cleared) + ccall( + (:SCIPsparseSolCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_SPARSESOL}}, Ptr{Ptr{SCIP_VAR}}, Cint, Cuint), + sparsesol, + vars, + nvars, + cleared, + ) end function SCIPsparseSolFree(sparsesol) - ccall((:SCIPsparseSolFree, libscip), Cvoid, (Ptr{Ptr{SCIP_SPARSESOL}},), 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) + ccall( + (:SCIPsparseSolGetVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_SPARSESOL},), + sparsesol, + ) end function SCIPsparseSolGetNVars(sparsesol) - ccall((:SCIPsparseSolGetNVars, libscip), Cint, (Ptr{SCIP_SPARSESOL},), sparsesol) + ccall( + (:SCIPsparseSolGetNVars, libscip), + Cint, + (Ptr{SCIP_SPARSESOL},), + sparsesol, + ) end function SCIPsparseSolGetLbs(sparsesol) - ccall((:SCIPsparseSolGetLbs, libscip), Ptr{Clonglong}, (Ptr{SCIP_SPARSESOL},), sparsesol) + ccall( + (:SCIPsparseSolGetLbs, libscip), + Ptr{Clonglong}, + (Ptr{SCIP_SPARSESOL},), + sparsesol, + ) end function SCIPsparseSolGetUbs(sparsesol) - ccall((:SCIPsparseSolGetUbs, libscip), Ptr{Clonglong}, (Ptr{SCIP_SPARSESOL},), 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) + ccall( + (:SCIPsparseSolGetFirstSol, libscip), + Cvoid, + (Ptr{SCIP_SPARSESOL}, Ptr{Clonglong}, Cint), + sparsesol, + sol, + nvars, + ) end function SCIPsparseSolGetNextSol(sparsesol, sol, nvars) - ccall((:SCIPsparseSolGetNextSol, libscip), Cuint, (Ptr{SCIP_SPARSESOL}, Ptr{Clonglong}, Cint), sparsesol, sol, nvars) + ccall( + (:SCIPsparseSolGetNextSol, libscip), + Cuint, + (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) + ccall( + (:SCIPqueueCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_QUEUE}}, Cint, Cdouble), + queue, + initsize, + sizefac, + ) end function SCIPqueueFree(queue) @@ -19965,11 +58208,23 @@ function SCIPqueueClear(queue) end function SCIPqueueInsert(queue, elem) - ccall((:SCIPqueueInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_QUEUE}, Ptr{Cvoid}), queue, elem) + ccall( + (:SCIPqueueInsert, libscip), + SCIP_RETCODE, + (Ptr{SCIP_QUEUE}, Ptr{Cvoid}), + queue, + elem, + ) end function SCIPqueueInsertUInt(queue, elem) - ccall((:SCIPqueueInsertUInt, libscip), SCIP_RETCODE, (Ptr{SCIP_QUEUE}, Cuint), queue, elem) + ccall( + (:SCIPqueueInsertUInt, libscip), + SCIP_RETCODE, + (Ptr{SCIP_QUEUE}, Cuint), + queue, + elem, + ) end function SCIPqueueRemove(queue) @@ -19997,7 +58252,16 @@ function SCIPqueueNElems(queue) end function SCIPpqueueCreate(pqueue, initsize, sizefac, ptrcomp, elemchgpos) - ccall((:SCIPpqueueCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_PQUEUE}}, Cint, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), pqueue, initsize, sizefac, ptrcomp, elemchgpos) + ccall( + (:SCIPpqueueCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_PQUEUE}}, Cint, Cdouble, Ptr{Cvoid}, Ptr{Cvoid}), + pqueue, + initsize, + sizefac, + ptrcomp, + elemchgpos, + ) end function SCIPpqueueFree(pqueue) @@ -20009,11 +58273,23 @@ function SCIPpqueueClear(pqueue) end function SCIPpqueueInsert(pqueue, elem) - ccall((:SCIPpqueueInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_PQUEUE}, Ptr{Cvoid}), pqueue, elem) + ccall( + (:SCIPpqueueInsert, libscip), + SCIP_RETCODE, + (Ptr{SCIP_PQUEUE}, Ptr{Cvoid}), + pqueue, + elem, + ) end function SCIPpqueueDelPos(pqueue, pos) - ccall((:SCIPpqueueDelPos, libscip), Cvoid, (Ptr{SCIP_PQUEUE}, Cint), pqueue, pos) + ccall( + (:SCIPpqueueDelPos, libscip), + Cvoid, + (Ptr{SCIP_PQUEUE}, Cint), + pqueue, + pos, + ) end function SCIPpqueueRemove(pqueue) @@ -20029,203 +58305,533 @@ function SCIPpqueueNElems(pqueue) end function SCIPpqueueElems(pqueue) - ccall((:SCIPpqueueElems, libscip), Ptr{Ptr{Cvoid}}, (Ptr{SCIP_PQUEUE},), pqueue) + ccall( + (:SCIPpqueueElems, libscip), + Ptr{Ptr{Cvoid}}, + (Ptr{SCIP_PQUEUE},), + pqueue, + ) end function SCIPpqueueFind(pqueue, elem) - ccall((:SCIPpqueueFind, libscip), Cint, (Ptr{SCIP_PQUEUE}, Ptr{Cvoid}), pqueue, elem) + ccall( + (:SCIPpqueueFind, libscip), + Cint, + (Ptr{SCIP_PQUEUE}, Ptr{Cvoid}), + pqueue, + elem, + ) 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) +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) + ccall( + (:SCIPhashtableFree, libscip), + Cvoid, + (Ptr{Ptr{SCIP_HASHTABLE}},), + hashtable, + ) end function SCIPhashtableInsert(hashtable, element) - ccall((:SCIPhashtableInsert, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), 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) + 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) + ccall( + (:SCIPhashtableRetrieve, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), + hashtable, + key, + ) end function SCIPhashtableExists(hashtable, element) - ccall((:SCIPhashtableExists, libscip), Cuint, (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), hashtable, element) + ccall( + (:SCIPhashtableExists, libscip), + Cuint, + (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), + hashtable, + element, + ) end function SCIPhashtableRemove(hashtable, element) - ccall((:SCIPhashtableRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHTABLE}, Ptr{Cvoid}), 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) + ccall( + (:SCIPhashtableRemoveAll, libscip), + Cvoid, + (Ptr{SCIP_HASHTABLE},), + hashtable, + ) end function SCIPhashtableGetNElements(hashtable) - ccall((:SCIPhashtableGetNElements, libscip), Clonglong, (Ptr{SCIP_HASHTABLE},), hashtable) + ccall( + (:SCIPhashtableGetNElements, libscip), + Clonglong, + (Ptr{SCIP_HASHTABLE},), + hashtable, + ) end function SCIPhashtableGetNEntries(hashtable) - ccall((:SCIPhashtableGetNEntries, libscip), Cint, (Ptr{SCIP_HASHTABLE},), 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) + ccall( + (:SCIPhashtableGetEntry, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_HASHTABLE}, Cint), + hashtable, + entryidx, + ) end function SCIPhashtableGetLoad(hashtable) - ccall((:SCIPhashtableGetLoad, libscip), Cdouble, (Ptr{SCIP_HASHTABLE},), 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) + 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) +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) + 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) + 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) + 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) + 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) + 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), Cuint, (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), multihash, element) + ccall( + (:SCIPmultihashExists, libscip), + Cuint, + (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), + multihash, + element, + ) end function SCIPmultihashRemove(multihash, element) - ccall((:SCIPmultihashRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_MULTIHASH}, Ptr{Cvoid}), 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) + ccall( + (:SCIPmultihashRemoveAll, libscip), + Cvoid, + (Ptr{SCIP_MULTIHASH},), + multihash, + ) end function SCIPmultihashGetNElements(multihash) - ccall((:SCIPmultihashGetNElements, libscip), Clonglong, (Ptr{SCIP_MULTIHASH},), multihash) + ccall( + (:SCIPmultihashGetNElements, libscip), + Clonglong, + (Ptr{SCIP_MULTIHASH},), + multihash, + ) end function SCIPmultihashGetLoad(multihash) - ccall((:SCIPmultihashGetLoad, libscip), Cdouble, (Ptr{SCIP_MULTIHASH},), 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) + ccall( + (:SCIPmultihashPrintStatistics, libscip), + Cvoid, + (Ptr{SCIP_MULTIHASH}, Ptr{SCIP_MESSAGEHDLR}), + multihash, + messagehdlr, + ) end function SCIPhashKeyEqString(userptr, key1, key2) - ccall((:SCIPhashKeyEqString, libscip), Cuint, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), userptr, key1, key2) + ccall( + (:SCIPhashKeyEqString, libscip), + Cuint, + (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), + userptr, + key1, + key2, + ) end function SCIPhashKeyValString(userptr, key) - ccall((:SCIPhashKeyValString, libscip), UInt64, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPhashGetKeyStandard, libscip), + Ptr{Cvoid}, + (Ptr{Cvoid}, Ptr{Cvoid}), + userptr, + elem, + ) end function SCIPhashKeyEqPtr(userptr, key1, key2) - ccall((:SCIPhashKeyEqPtr, libscip), Cuint, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), userptr, key1, key2) + ccall( + (:SCIPhashKeyEqPtr, libscip), + Cuint, + (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), + userptr, + key1, + key2, + ) end function SCIPhashKeyValPtr(userptr, key) - ccall((:SCIPhashKeyValPtr, libscip), UInt64, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + 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) + 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) + ccall( + (:SCIPhashmapInsert, libscip), + SCIP_RETCODE, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Ptr{Cvoid}), + hashmap, + origin, + image, + ) end function SCIPhashmapInsertLong(hashmap, origin, image) - ccall((:SCIPhashmapInsertLong, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Clonglong), hashmap, origin, image) + ccall( + (:SCIPhashmapInsertLong, libscip), + SCIP_RETCODE, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Clonglong), + hashmap, + origin, + image, + ) end function SCIPhashmapInsertInt(hashmap, origin, image) - ccall((:SCIPhashmapInsertInt, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cint), hashmap, origin, image) + ccall( + (:SCIPhashmapInsertInt, libscip), + SCIP_RETCODE, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cint), + hashmap, + origin, + image, + ) end function SCIPhashmapInsertReal(hashmap, origin, image) - ccall((:SCIPhashmapInsertReal, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cdouble), 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) + ccall( + (:SCIPhashmapGetImage, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), + hashmap, + origin, + ) end function SCIPhashmapGetImageInt(hashmap, origin) - ccall((:SCIPhashmapGetImageInt, libscip), Cint, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), hashmap, origin) + ccall( + (:SCIPhashmapGetImageInt, libscip), + Cint, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), + hashmap, + origin, + ) end function SCIPhashmapGetImageLong(hashmap, origin) - ccall((:SCIPhashmapGetImageLong, libscip), Clonglong, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), hashmap, origin) + ccall( + (:SCIPhashmapGetImageLong, libscip), + Clonglong, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), + hashmap, + origin, + ) end function SCIPhashmapGetImageReal(hashmap, origin) - ccall((:SCIPhashmapGetImageReal, libscip), Cdouble, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), 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) + ccall( + (:SCIPhashmapSetImage, libscip), + SCIP_RETCODE, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Ptr{Cvoid}), + hashmap, + origin, + image, + ) end function SCIPhashmapSetImageInt(hashmap, origin, image) - ccall((:SCIPhashmapSetImageInt, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cint), hashmap, origin, image) + ccall( + (:SCIPhashmapSetImageInt, libscip), + SCIP_RETCODE, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cint), + hashmap, + origin, + image, + ) end function SCIPhashmapSetImageReal(hashmap, origin, image) - ccall((:SCIPhashmapSetImageReal, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}, Cdouble), 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), Cuint, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), hashmap, origin) + ccall( + (:SCIPhashmapExists, libscip), + Cuint, + (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), + hashmap, + origin, + ) end function SCIPhashmapRemove(hashmap, origin) - ccall((:SCIPhashmapRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHMAP}, Ptr{Cvoid}), 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) + ccall( + (:SCIPhashmapPrintStatistics, libscip), + Cvoid, + (Ptr{SCIP_HASHMAP}, Ptr{SCIP_MESSAGEHDLR}), + hashmap, + messagehdlr, + ) end function SCIPhashmapIsEmpty(hashmap) @@ -20233,71 +58839,168 @@ function SCIPhashmapIsEmpty(hashmap) end function SCIPhashmapGetNElements(hashmap) - ccall((:SCIPhashmapGetNElements, libscip), Cint, (Ptr{SCIP_HASHMAP},), hashmap) + ccall( + (:SCIPhashmapGetNElements, libscip), + Cint, + (Ptr{SCIP_HASHMAP},), + hashmap, + ) end function SCIPhashmapGetNEntries(hashmap) - ccall((:SCIPhashmapGetNEntries, libscip), Cint, (Ptr{SCIP_HASHMAP},), 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) + 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) + ccall( + (:SCIPhashmapEntryGetOrigin, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_HASHMAPENTRY},), + entry, + ) end function SCIPhashmapEntryGetImage(entry) - ccall((:SCIPhashmapEntryGetImage, libscip), Ptr{Cvoid}, (Ptr{SCIP_HASHMAPENTRY},), entry) + ccall( + (:SCIPhashmapEntryGetImage, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_HASHMAPENTRY},), + entry, + ) end function SCIPhashmapEntryGetImageInt(entry) - ccall((:SCIPhashmapEntryGetImageInt, libscip), Cint, (Ptr{SCIP_HASHMAPENTRY},), entry) + ccall( + (:SCIPhashmapEntryGetImageInt, libscip), + Cint, + (Ptr{SCIP_HASHMAPENTRY},), + entry, + ) end function SCIPhashmapEntryGetImageReal(entry) - ccall((:SCIPhashmapEntryGetImageReal, libscip), Cdouble, (Ptr{SCIP_HASHMAPENTRY},), 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) + ccall( + (:SCIPhashmapEntrySetImage, libscip), + Cvoid, + (Ptr{SCIP_HASHMAPENTRY}, Ptr{Cvoid}), + entry, + image, + ) end function SCIPhashmapEntrySetImageInt(entry, image) - ccall((:SCIPhashmapEntrySetImageInt, libscip), Cvoid, (Ptr{SCIP_HASHMAPENTRY}, Cint), entry, image) + ccall( + (:SCIPhashmapEntrySetImageInt, libscip), + Cvoid, + (Ptr{SCIP_HASHMAPENTRY}, Cint), + entry, + image, + ) end function SCIPhashmapEntrySetImageReal(entry, image) - ccall((:SCIPhashmapEntrySetImageReal, libscip), Cvoid, (Ptr{SCIP_HASHMAPENTRY}, Cdouble), 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) + 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) + 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) + 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) + ccall( + (:SCIPhashsetInsert, libscip), + SCIP_RETCODE, + (Ptr{SCIP_HASHSET}, Ptr{BMS_BLKMEM}, Ptr{Cvoid}), + hashset, + blkmem, + element, + ) end function SCIPhashsetExists(hashset, element) - ccall((:SCIPhashsetExists, libscip), Cuint, (Ptr{SCIP_HASHSET}, Ptr{Cvoid}), hashset, element) + ccall( + (:SCIPhashsetExists, libscip), + Cuint, + (Ptr{SCIP_HASHSET}, Ptr{Cvoid}), + hashset, + element, + ) end function SCIPhashsetRemove(hashset, element) - ccall((:SCIPhashsetRemove, libscip), SCIP_RETCODE, (Ptr{SCIP_HASHSET}, Ptr{Cvoid}), 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) + ccall( + (:SCIPhashsetPrintStatistics, libscip), + Cvoid, + (Ptr{SCIP_HASHSET}, Ptr{SCIP_MESSAGEHDLR}), + hashset, + messagehdlr, + ) end function SCIPhashsetIsEmpty(hashset) @@ -20305,7 +59008,12 @@ function SCIPhashsetIsEmpty(hashset) end function SCIPhashsetGetNElements(hashset) - ccall((:SCIPhashsetGetNElements, libscip), Cint, (Ptr{SCIP_HASHSET},), hashset) + ccall( + (:SCIPhashsetGetNElements, libscip), + Cint, + (Ptr{SCIP_HASHSET},), + hashset, + ) end function SCIPhashsetGetNSlots(hashset) @@ -20313,115 +59021,307 @@ function SCIPhashsetGetNSlots(hashset) end function SCIPhashsetGetSlots(hashset) - ccall((:SCIPhashsetGetSlots, libscip), Ptr{Ptr{Cvoid}}, (Ptr{SCIP_HASHSET},), hashset) + ccall( + (:SCIPhashsetGetSlots, libscip), + Ptr{Ptr{Cvoid}}, + (Ptr{SCIP_HASHSET},), + hashset, + ) end function SCIPhashsetRemoveAll(hashset) - ccall((:SCIPhashsetRemoveAll, libscip), Cvoid, (Ptr{SCIP_HASHSET},), 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) + 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) + ccall( + (:SCIPactivityFree, libscip), + Cvoid, + (Ptr{Ptr{SCIP_RESOURCEACTIVITY}},), + activity, + ) end function SCIPactivityGetVar(activity) - ccall((:SCIPactivityGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_RESOURCEACTIVITY},), activity) + ccall( + (:SCIPactivityGetVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_RESOURCEACTIVITY},), + activity, + ) end function SCIPactivityGetDuration(activity) - ccall((:SCIPactivityGetDuration, libscip), Cint, (Ptr{SCIP_RESOURCEACTIVITY},), activity) + ccall( + (:SCIPactivityGetDuration, libscip), + Cint, + (Ptr{SCIP_RESOURCEACTIVITY},), + activity, + ) end function SCIPactivityGetDemand(activity) - ccall((:SCIPactivityGetDemand, libscip), Cint, (Ptr{SCIP_RESOURCEACTIVITY},), activity) + ccall( + (:SCIPactivityGetDemand, libscip), + Cint, + (Ptr{SCIP_RESOURCEACTIVITY},), + activity, + ) end function SCIPactivityGetEnergy(activity) - ccall((:SCIPactivityGetEnergy, libscip), Cint, (Ptr{SCIP_RESOURCEACTIVITY},), 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) + 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) + 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{Libc.FILE}), profile, messagehdlr, file) + ccall( + (:SCIPprofilePrint, libscip), + Cvoid, + (Ptr{SCIP_PROFILE}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), + profile, + messagehdlr, + file, + ) end function SCIPprofileGetCapacity(profile) - ccall((:SCIPprofileGetCapacity, libscip), Cint, (Ptr{SCIP_PROFILE},), profile) + ccall( + (:SCIPprofileGetCapacity, libscip), + Cint, + (Ptr{SCIP_PROFILE},), + profile, + ) end function SCIPprofileGetNTimepoints(profile) - ccall((:SCIPprofileGetNTimepoints, libscip), Cint, (Ptr{SCIP_PROFILE},), profile) + ccall( + (:SCIPprofileGetNTimepoints, libscip), + Cint, + (Ptr{SCIP_PROFILE},), + profile, + ) end function SCIPprofileGetTimepoints(profile) - ccall((:SCIPprofileGetTimepoints, libscip), Ptr{Cint}, (Ptr{SCIP_PROFILE},), profile) + ccall( + (:SCIPprofileGetTimepoints, libscip), + Ptr{Cint}, + (Ptr{SCIP_PROFILE},), + profile, + ) end function SCIPprofileGetLoads(profile) - ccall((:SCIPprofileGetLoads, libscip), Ptr{Cint}, (Ptr{SCIP_PROFILE},), 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) + 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) + ccall( + (:SCIPprofileGetLoad, libscip), + Cint, + (Ptr{SCIP_PROFILE}, Cint), + profile, + pos, + ) end function SCIPprofileFindLeft(profile, timepoint, pos) - ccall((:SCIPprofileFindLeft, libscip), Cuint, (Ptr{SCIP_PROFILE}, Cint, Ptr{Cint}), profile, timepoint, pos) + ccall( + (:SCIPprofileFindLeft, libscip), + Cuint, + (Ptr{SCIP_PROFILE}, Cint, Ptr{Cint}), + profile, + timepoint, + pos, + ) end function SCIPprofileInsertCore(profile, left, right, demand, pos, infeasible) - ccall((:SCIPprofileInsertCore, libscip), SCIP_RETCODE, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cuint}), profile, left, right, demand, pos, infeasible) + ccall( + (:SCIPprofileInsertCore, libscip), + SCIP_RETCODE, + (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Ptr{Cint}, Ptr{Cuint}), + profile, + left, + right, + demand, + pos, + infeasible, + ) end function SCIPprofileDeleteCore(profile, left, right, demand) - ccall((:SCIPprofileDeleteCore, libscip), SCIP_RETCODE, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint), profile, left, right, demand) -end - -function SCIPprofileGetEarliestFeasibleStart(profile, est, lst, duration, demand, infeasible) - ccall((:SCIPprofileGetEarliestFeasibleStart, libscip), Cint, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Cint, Ptr{Cuint}), profile, est, lst, duration, demand, infeasible) -end - -function SCIPprofileGetLatestFeasibleStart(profile, est, lst, duration, demand, infeasible) - ccall((:SCIPprofileGetLatestFeasibleStart, libscip), Cint, (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Cint, Ptr{Cuint}), profile, est, lst, duration, demand, infeasible) + ccall( + (:SCIPprofileDeleteCore, libscip), + SCIP_RETCODE, + (Ptr{SCIP_PROFILE}, Cint, Cint, Cint), + profile, + left, + right, + demand, + ) +end + +function SCIPprofileGetEarliestFeasibleStart( + profile, + est, + lst, + duration, + demand, + infeasible, +) + ccall( + (:SCIPprofileGetEarliestFeasibleStart, libscip), + Cint, + (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Cint, Ptr{Cuint}), + profile, + est, + lst, + duration, + demand, + infeasible, + ) +end + +function SCIPprofileGetLatestFeasibleStart( + profile, + est, + lst, + duration, + demand, + infeasible, +) + ccall( + (:SCIPprofileGetLatestFeasibleStart, libscip), + Cint, + (Ptr{SCIP_PROFILE}, Cint, Cint, Cint, Cint, Ptr{Cuint}), + profile, + est, + lst, + duration, + demand, + infeasible, + ) end function SCIPdigraphResize(digraph, nnodes) - ccall((:SCIPdigraphResize, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Cint), 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPdigraphSetNSuccessors, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DIGRAPH}, Cint, Cint), + digraph, + node, + nsuccessors, + ) end function SCIPdigraphGetNNodes(digraph) @@ -20429,11 +59329,24 @@ function SCIPdigraphGetNNodes(digraph) end function SCIPdigraphGetNodeData(digraph, node) - ccall((:SCIPdigraphGetNodeData, libscip), Ptr{Cvoid}, (Ptr{SCIP_DIGRAPH}, Cint), 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) + ccall( + (:SCIPdigraphSetNodeData, libscip), + Cvoid, + (Ptr{SCIP_DIGRAPH}, Ptr{Cvoid}, Cint), + digraph, + dataptr, + node, + ) end function SCIPdigraphGetNArcs(digraph) @@ -20441,63 +59354,176 @@ function SCIPdigraphGetNArcs(digraph) end function SCIPdigraphGetNSuccessors(digraph, node) - ccall((:SCIPdigraphGetNSuccessors, libscip), Cint, (Ptr{SCIP_DIGRAPH}, Cint), 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) + 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 SCIPdigraphGetArticulationPoints(digraph, articulations, narticulations) - ccall((:SCIPdigraphGetArticulationPoints, libscip), SCIP_RETCODE, (Ptr{SCIP_DIGRAPH}, Ptr{Ptr{Cint}}, Ptr{Cint}), digraph, articulations, narticulations) -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) + ccall( + (:SCIPdigraphGetSuccessorsData, libscip), + Ptr{Ptr{Cvoid}}, + (Ptr{SCIP_DIGRAPH}, Cint), + digraph, + node, + ) +end + +function SCIPdigraphGetArticulationPoints( + digraph, + articulations, + narticulations, +) + ccall( + (:SCIPdigraphGetArticulationPoints, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DIGRAPH}, Ptr{Ptr{Cint}}, Ptr{Cint}), + digraph, + articulations, + narticulations, + ) +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) + ccall( + (:SCIPdigraphTopoSortComponents, libscip), + SCIP_RETCODE, + (Ptr{SCIP_DIGRAPH},), + digraph, + ) end function SCIPdigraphGetNComponents(digraph) - ccall((:SCIPdigraphGetNComponents, libscip), Cint, (Ptr{SCIP_DIGRAPH},), 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) + 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) + 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{Libc.FILE}), digraph, messagehdlr, file) + ccall( + (:SCIPdigraphPrint, libscip), + Cvoid, + (Ptr{SCIP_DIGRAPH}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), + digraph, + messagehdlr, + file, + ) end function SCIPdigraphPrintGml(digraph, file) - ccall((:SCIPdigraphPrintGml, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Ptr{Libc.FILE}), digraph, file) + ccall( + (:SCIPdigraphPrintGml, libscip), + Cvoid, + (Ptr{SCIP_DIGRAPH}, Ptr{Libc.FILE}), + digraph, + file, + ) end function SCIPdigraphPrintComponents(digraph, messagehdlr, file) - ccall((:SCIPdigraphPrintComponents, libscip), Cvoid, (Ptr{SCIP_DIGRAPH}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.FILE}), digraph, messagehdlr, file) + ccall( + (:SCIPdigraphPrintComponents, libscip), + Cvoid, + (Ptr{SCIP_DIGRAPH}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Libc.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) + 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) + ccall( + (:SCIPbtnodeFree, libscip), + Cvoid, + (Ptr{SCIP_BT}, Ptr{Ptr{SCIP_BTNODE}}), + tree, + node, + ) end function SCIPbtnodeGetData(node) @@ -20505,19 +59531,39 @@ function SCIPbtnodeGetData(node) end function SCIPbtnodeGetParent(node) - ccall((:SCIPbtnodeGetParent, libscip), Ptr{SCIP_BTNODE}, (Ptr{SCIP_BTNODE},), 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) + ccall( + (:SCIPbtnodeGetLeftchild, libscip), + Ptr{SCIP_BTNODE}, + (Ptr{SCIP_BTNODE},), + node, + ) end function SCIPbtnodeGetRightchild(node) - ccall((:SCIPbtnodeGetRightchild, libscip), Ptr{SCIP_BTNODE}, (Ptr{SCIP_BTNODE},), 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) + ccall( + (:SCIPbtnodeGetSibling, libscip), + Ptr{SCIP_BTNODE}, + (Ptr{SCIP_BTNODE},), + node, + ) end function SCIPbtnodeIsRoot(node) @@ -20537,23 +59583,53 @@ function SCIPbtnodeIsRightchild(node) end function SCIPbtnodeSetData(node, dataptr) - ccall((:SCIPbtnodeSetData, libscip), Cvoid, (Ptr{SCIP_BTNODE}, Ptr{Cvoid}), 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) + 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) + 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) + 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) + ccall( + (:SCIPbtCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_BT}}, Ptr{BMS_BLKMEM}), + tree, + blkmem, + ) end function SCIPbtFree(tree) @@ -20561,7 +59637,13 @@ function SCIPbtFree(tree) end function SCIPbtPrintGml(tree, file) - ccall((:SCIPbtPrintGml, libscip), Cvoid, (Ptr{SCIP_BT}, Ptr{Libc.FILE}), tree, file) + ccall( + (:SCIPbtPrintGml, libscip), + Cvoid, + (Ptr{SCIP_BT}, Ptr{Libc.FILE}), + tree, + file, + ) end function SCIPbtIsEmpty(tree) @@ -20573,27 +59655,62 @@ function SCIPbtGetRoot(tree) end function SCIPbtSetRoot(tree, root) - ccall((:SCIPbtSetRoot, libscip), Cvoid, (Ptr{SCIP_BT}, Ptr{SCIP_BTNODE}), 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) + ccall( + (:SCIPdisjointsetClear, libscip), + Cvoid, + (Ptr{SCIP_DISJOINTSET},), + djset, + ) end function SCIPdisjointsetFind(djset, element) - ccall((:SCIPdisjointsetFind, libscip), Cint, (Ptr{SCIP_DISJOINTSET}, Cint), 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, Cuint), djset, p, q, forcerepofp) + ccall( + (:SCIPdisjointsetUnion, libscip), + Cvoid, + (Ptr{SCIP_DISJOINTSET}, Cint, Cint, Cuint), + djset, + p, + q, + forcerepofp, + ) end function SCIPdisjointsetGetComponentCount(djset) - ccall((:SCIPdisjointsetGetComponentCount, libscip), Cint, (Ptr{SCIP_DISJOINTSET},), djset) + ccall( + (:SCIPdisjointsetGetComponentCount, libscip), + Cint, + (Ptr{SCIP_DISJOINTSET},), + djset, + ) end function SCIPdisjointsetGetSize(djset) - ccall((:SCIPdisjointsetGetSize, libscip), Cint, (Ptr{SCIP_DISJOINTSET},), djset) + ccall( + (:SCIPdisjointsetGetSize, libscip), + Cint, + (Ptr{SCIP_DISJOINTSET},), + djset, + ) end function SCIPcalcMachineEpsilon() @@ -20605,11 +59722,23 @@ function SCIPnextafter(from, to) end function SCIPcalcGreComDiv(val1, val2) - ccall((:SCIPcalcGreComDiv, libscip), Clonglong, (Clonglong, Clonglong), val1, val2) + ccall( + (:SCIPcalcGreComDiv, libscip), + Clonglong, + (Clonglong, Clonglong), + val1, + val2, + ) end function SCIPcalcSmaComMul(val1, val2) - ccall((:SCIPcalcSmaComMul, libscip), Clonglong, (Clonglong, Clonglong), val1, val2) + ccall( + (:SCIPcalcSmaComMul, libscip), + Clonglong, + (Clonglong, Clonglong), + val1, + val2, + ) end function SCIPcalcBinomCoef(n, m) @@ -20620,32 +59749,130 @@ function SCIPcalcFibHash(v) ccall((:SCIPcalcFibHash, libscip), Cuint, (Cdouble,), v) end -function SCIPrealToRational(val, mindelta, maxdelta, maxdnom, numerator, denominator) - ccall((:SCIPrealToRational, libscip), Cuint, (Cdouble, Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), val, mindelta, maxdelta, maxdnom, numerator, denominator) +function SCIPrealToRational( + val, + mindelta, + maxdelta, + maxdnom, + numerator, + denominator, +) + ccall( + (:SCIPrealToRational, libscip), + Cuint, + (Cdouble, Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), + val, + mindelta, + maxdelta, + maxdnom, + numerator, + denominator, + ) end function SCIPrealIsExactlyIntegral(val) ccall((:SCIPrealIsExactlyIntegral, libscip), Cuint, (Cdouble,), val) 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{Cuint}), vals, nvals, mindelta, maxdelta, maxdnom, maxscale, intscalar, success) -end - -function SCIPcalcIntegralScalarExact(buffer, vals, nvals, maxscale, intscalar, success) - ccall((:SCIPcalcIntegralScalarExact, libscip), SCIP_RETCODE, (Ptr{BMS_BUFMEM}, Ptr{Ptr{SCIP_RATIONAL}}, Cint, Cdouble, Ptr{SCIP_RATIONAL}, Ptr{Cuint}), buffer, vals, nvals, maxscale, intscalar, success) +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{Cuint}, + ), + vals, + nvals, + mindelta, + maxdelta, + maxdnom, + maxscale, + intscalar, + success, + ) +end + +function SCIPcalcIntegralScalarExact( + buffer, + vals, + nvals, + maxscale, + intscalar, + success, +) + ccall( + (:SCIPcalcIntegralScalarExact, libscip), + SCIP_RETCODE, + ( + Ptr{BMS_BUFMEM}, + Ptr{Ptr{SCIP_RATIONAL}}, + Cint, + Cdouble, + Ptr{SCIP_RATIONAL}, + Ptr{Cuint}, + ), + buffer, + vals, + nvals, + maxscale, + intscalar, + success, + ) end function SCIPfindSimpleRational(lb, ub, maxdnom, numerator, denominator) - ccall((:SCIPfindSimpleRational, libscip), Cuint, (Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), lb, ub, maxdnom, numerator, denominator) + ccall( + (:SCIPfindSimpleRational, libscip), + Cuint, + (Cdouble, Cdouble, Clonglong, Ptr{Clonglong}, Ptr{Clonglong}), + lb, + ub, + maxdnom, + numerator, + denominator, + ) end function SCIPselectSimpleValue(lb, ub, maxdnom) - ccall((:SCIPselectSimpleValue, libscip), Cdouble, (Cdouble, Cdouble, Clonglong), lb, ub, maxdnom) + ccall( + (:SCIPselectSimpleValue, libscip), + Cdouble, + (Cdouble, Cdouble, Clonglong), + lb, + ub, + maxdnom, + ) end function SCIPcalcRootNewton(_function, derivative, params, nparams, x, eps, k) - ccall((:SCIPcalcRootNewton, libscip), Cdouble, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cdouble}, Cint, Cdouble, Cdouble, Cint), _function, derivative, params, nparams, x, eps, k) + ccall( + (:SCIPcalcRootNewton, libscip), + Cdouble, + (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cdouble}, Cint, Cdouble, Cdouble, Cint), + _function, + derivative, + params, + nparams, + x, + eps, + k, + ) end function SCIPrelDiff(val1, val2) @@ -20653,55 +59880,189 @@ function SCIPrelDiff(val1, val2) end function SCIPcomputeGap(eps, inf, primalbound, dualbound) - ccall((:SCIPcomputeGap, libscip), Cdouble, (Cdouble, Cdouble, Cdouble, Cdouble), eps, inf, primalbound, dualbound) + ccall( + (:SCIPcomputeGap, libscip), + Cdouble, + (Cdouble, Cdouble, Cdouble, Cdouble), + eps, + inf, + primalbound, + dualbound, + ) end function SCIPrandomGetInt(randnumgen, minrandval, maxrandval) - ccall((:SCIPrandomGetInt, libscip), Cint, (Ptr{SCIP_RANDNUMGEN}, Cint, Cint), randnumgen, minrandval, maxrandval) + ccall( + (:SCIPrandomGetInt, libscip), + Cint, + (Ptr{SCIP_RANDNUMGEN}, Cint, Cint), + randnumgen, + minrandval, + maxrandval, + ) end function SCIPrandomGetSubset(randnumgen, set, nelems, subset, nsubelems) - ccall((:SCIPrandomGetSubset, libscip), SCIP_RETCODE, (Ptr{SCIP_RANDNUMGEN}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Ptr{Cvoid}}, Cint), randnumgen, set, nelems, subset, nsubelems) + ccall( + (:SCIPrandomGetSubset, libscip), + SCIP_RETCODE, + (Ptr{SCIP_RANDNUMGEN}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Ptr{Cvoid}}, Cint), + randnumgen, + set, + nelems, + subset, + nsubelems, + ) end function SCIPrandomGetReal(randnumgen, minrandval, maxrandval) - ccall((:SCIPrandomGetReal, libscip), Cdouble, (Ptr{SCIP_RANDNUMGEN}, Cdouble, Cdouble), randnumgen, minrandval, maxrandval) + ccall( + (:SCIPrandomGetReal, libscip), + Cdouble, + (Ptr{SCIP_RANDNUMGEN}, Cdouble, Cdouble), + randnumgen, + minrandval, + maxrandval, + ) end function SCIPswapInts(value1, value2) - ccall((:SCIPswapInts, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}), 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) + 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) + ccall( + (:SCIPswapPointers, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}), + pointer1, + pointer2, + ) end function SCIPrandomPermuteIntArray(randnumgen, array, _begin, _end) - ccall((:SCIPrandomPermuteIntArray, libscip), Cvoid, (Ptr{SCIP_RANDNUMGEN}, Ptr{Cint}, Cint, Cint), randnumgen, array, _begin, _end) + ccall( + (:SCIPrandomPermuteIntArray, libscip), + Cvoid, + (Ptr{SCIP_RANDNUMGEN}, Ptr{Cint}, Cint, Cint), + randnumgen, + array, + _begin, + _end, + ) end function SCIPrandomPermuteArray(randnumgen, array, _begin, _end) - ccall((:SCIPrandomPermuteArray, libscip), Cvoid, (Ptr{SCIP_RANDNUMGEN}, Ptr{Ptr{Cvoid}}, Cint, Cint), randnumgen, array, _begin, _end) -end - -function SCIPcomputeArraysIntersectionInt(array1, narray1, array2, narray2, intersectarray, nintersectarray) - ccall((:SCIPcomputeArraysIntersectionInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), array1, narray1, array2, narray2, intersectarray, nintersectarray) -end - -function SCIPcomputeArraysIntersectionPtr(array1, narray1, array2, narray2, ptrcomp, intersectarray, nintersectarray) - ccall((:SCIPcomputeArraysIntersectionPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Cint, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cvoid}, Ptr{Ptr{Cvoid}}, Ptr{Cint}), array1, narray1, array2, narray2, ptrcomp, intersectarray, nintersectarray) -end - -function SCIPcomputeArraysSetminusInt(array1, narray1, array2, narray2, setminusarray, nsetminusarray) - ccall((:SCIPcomputeArraysSetminusInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), array1, narray1, array2, narray2, setminusarray, nsetminusarray) + ccall( + (:SCIPrandomPermuteArray, libscip), + Cvoid, + (Ptr{SCIP_RANDNUMGEN}, Ptr{Ptr{Cvoid}}, Cint, Cint), + randnumgen, + array, + _begin, + _end, + ) +end + +function SCIPcomputeArraysIntersectionInt( + array1, + narray1, + array2, + narray2, + intersectarray, + nintersectarray, +) + ccall( + (:SCIPcomputeArraysIntersectionInt, libscip), + Cvoid, + (Ptr{Cint}, Cint, Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), + array1, + narray1, + array2, + narray2, + intersectarray, + nintersectarray, + ) +end + +function SCIPcomputeArraysIntersectionPtr( + array1, + narray1, + array2, + narray2, + ptrcomp, + intersectarray, + nintersectarray, +) + ccall( + (:SCIPcomputeArraysIntersectionPtr, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Cint, + Ptr{Ptr{Cvoid}}, + Cint, + Ptr{Cvoid}, + Ptr{Ptr{Cvoid}}, + Ptr{Cint}, + ), + array1, + narray1, + array2, + narray2, + ptrcomp, + intersectarray, + nintersectarray, + ) +end + +function SCIPcomputeArraysSetminusInt( + array1, + narray1, + array2, + narray2, + setminusarray, + nsetminusarray, +) + ccall( + (:SCIPcomputeArraysSetminusInt, libscip), + Cvoid, + (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, (Ptr{Cchar}, Ptr{Cchar}, Cchar, Cuint), dest, src, stop, cnt) + ccall( + (:SCIPmemccpy, libscip), + Cint, + (Ptr{Cchar}, Ptr{Cchar}, Cchar, Cuint), + dest, + src, + stop, + cnt, + ) end function SCIPprintSysError(message) @@ -20709,11 +60070,25 @@ function SCIPprintSysError(message) end function SCIPstrtok(s, delim, ptrptr) - ccall((:SCIPstrtok, libscip), Ptr{Cchar}, (Ptr{Cchar}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), s, delim, ptrptr) + ccall( + (:SCIPstrtok, libscip), + Ptr{Cchar}, + (Ptr{Cchar}, Ptr{Cchar}, Ptr{Ptr{Cchar}}), + s, + delim, + ptrptr, + ) end function SCIPescapeString(t, bufsize, s) - ccall((:SCIPescapeString, libscip), Cvoid, (Ptr{Cchar}, Cint, Ptr{Cchar}), t, bufsize, s) + ccall( + (:SCIPescapeString, libscip), + Cvoid, + (Ptr{Cchar}, Cint, Ptr{Cchar}), + t, + bufsize, + s, + ) end function SCIPskipSpace(s) @@ -20721,7 +60096,14 @@ function SCIPskipSpace(s) end function SCIPstrncpy(t, s, size) - ccall((:SCIPstrncpy, libscip), Cint, (Ptr{Cchar}, Ptr{Cchar}, Cint), t, s, size) + ccall( + (:SCIPstrncpy, libscip), + Cint, + (Ptr{Cchar}, Ptr{Cchar}, Cint), + t, + s, + size, + ) end function SCIPstrcasecmp(s1, s2) @@ -20729,23 +60111,61 @@ function SCIPstrcasecmp(s1, s2) end function SCIPstrncasecmp(s1, s2, length) - ccall((:SCIPstrncasecmp, libscip), Cint, (Ptr{Cchar}, Ptr{Cchar}, Cint), s1, s2, length) + ccall( + (:SCIPstrncasecmp, libscip), + Cint, + (Ptr{Cchar}, Ptr{Cchar}, Cint), + s1, + s2, + length, + ) end function SCIPstrToIntValue(str, value, endptr) - ccall((:SCIPstrToIntValue, libscip), Cuint, (Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{Cchar}}), str, value, endptr) + ccall( + (:SCIPstrToIntValue, libscip), + Cuint, + (Ptr{Cchar}, Ptr{Cint}, Ptr{Ptr{Cchar}}), + str, + value, + endptr, + ) end function SCIPstrToRealValue(str, value, endptr) - ccall((:SCIPstrToRealValue, libscip), Cuint, (Ptr{Cchar}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), str, value, endptr) + ccall( + (:SCIPstrToRealValue, libscip), + Cuint, + (Ptr{Cchar}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}), + str, + value, + endptr, + ) end function SCIPstrCopySection(str, startchar, endchar, token, size, endptr) - ccall((:SCIPstrCopySection, libscip), Cvoid, (Ptr{Cchar}, Cchar, Cchar, Ptr{Cchar}, Cint, Ptr{Ptr{Cchar}}), str, startchar, endchar, token, size, endptr) + ccall( + (:SCIPstrCopySection, libscip), + Cvoid, + (Ptr{Cchar}, Cchar, Cchar, Ptr{Cchar}, Cint, Ptr{Ptr{Cchar}}), + str, + startchar, + endchar, + token, + size, + endptr, + ) end function SCIPstrAtStart(s, t, tlen) - ccall((:SCIPstrAtStart, libscip), Cuint, (Ptr{Cchar}, Ptr{Cchar}, Csize_t), s, t, tlen) + ccall( + (:SCIPstrAtStart, libscip), + Cuint, + (Ptr{Cchar}, Ptr{Cchar}, Csize_t), + s, + t, + tlen, + ) end function SCIPfileExists(filename) @@ -20753,63 +60173,182 @@ function SCIPfileExists(filename) end function SCIPsplitFilename(filename, path, name, extension, compression) - ccall((:SCIPsplitFilename, libscip), Cvoid, (Ptr{Cchar}, Ptr{Ptr{Cchar}}, Ptr{Ptr{Cchar}}, Ptr{Ptr{Cchar}}, Ptr{Ptr{Cchar}}), filename, path, name, extension, compression) + ccall( + (:SCIPsplitFilename, libscip), + Cvoid, + ( + Ptr{Cchar}, + Ptr{Ptr{Cchar}}, + Ptr{Ptr{Cchar}}, + Ptr{Ptr{Cchar}}, + Ptr{Ptr{Cchar}}, + ), + filename, + path, + name, + extension, + compression, + ) end function SCIPconsGetRhs(scip, cons, success) - ccall((:SCIPconsGetRhs, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) + ccall( + (:SCIPconsGetRhs, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), + scip, + cons, + success, + ) end function SCIPconsGetLhs(scip, cons, success) - ccall((:SCIPconsGetLhs, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) + ccall( + (:SCIPconsGetLhs, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), + scip, + cons, + success, + ) end function SCIPconsGetRhsExact(scip, cons, success) - ccall((:SCIPconsGetRhsExact, libscip), Ptr{Cint}, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) + ccall( + (:SCIPconsGetRhsExact, libscip), + Ptr{Cint}, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), + scip, + cons, + success, + ) end function SCIPconsGetLhsExact(scip, cons, success) - ccall((:SCIPconsGetLhsExact, libscip), Ptr{Cint}, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), scip, cons, success) + ccall( + (:SCIPconsGetLhsExact, libscip), + Ptr{Cint}, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cuint}), + 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{Cuint}), scip, cons, vals, varssize, success) + ccall( + (:SCIPgetConsVals, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Cint, Ptr{Cuint}), + scip, + cons, + vals, + varssize, + success, + ) end function SCIPgetConsValsExact(scip, cons, vals, varssize, success) - ccall((:SCIPgetConsValsExact, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{Cint}}, Cint, Ptr{Cuint}), scip, cons, vals, varssize, success) + ccall( + (:SCIPgetConsValsExact, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{Cint}}, Cint, Ptr{Cuint}), + scip, + cons, + vals, + varssize, + success, + ) end function SCIPconsGetDualfarkas(scip, cons, dualfarkas, success) - ccall((:SCIPconsGetDualfarkas, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), scip, cons, dualfarkas, success) + ccall( + (:SCIPconsGetDualfarkas, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), + scip, + cons, + dualfarkas, + success, + ) end function SCIPconsGetDualsol(scip, cons, dualsol, success) - ccall((:SCIPconsGetDualsol, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), scip, cons, dualsol, success) + ccall( + (:SCIPconsGetDualsol, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Cdouble}, Ptr{Cuint}), + scip, + cons, + dualsol, + success, + ) end function SCIPconsGetRow(scip, cons) - ccall((:SCIPconsGetRow, libscip), Ptr{SCIP_ROW}, (Ptr{SCIP}, Ptr{SCIP_CONS}), scip, cons) + ccall( + (:SCIPconsGetRow, libscip), + Ptr{SCIP_ROW}, + (Ptr{SCIP}, Ptr{SCIP_CONS}), + scip, + cons, + ) end function SCIPconsCreateRow(scip, cons, row) - ccall((:SCIPconsCreateRow, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_ROW}}), scip, cons, row) + ccall( + (:SCIPconsCreateRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{Ptr{SCIP_ROW}}), + scip, + cons, + row, + ) end function SCIPconsAddCoef(scip, cons, var, val) - ccall((:SCIPconsAddCoef, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), scip, cons, var, val) + ccall( + (:SCIPconsAddCoef, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_CONS}, Ptr{SCIP_VAR}, Cdouble), + scip, + cons, + var, + val, + ) end function SCIPcreateRowprep(scip, rowprep, sidetype, _local) - ccall((:SCIPcreateRowprep, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}, SCIP_SIDETYPE, Cuint), scip, rowprep, sidetype, _local) + ccall( + (:SCIPcreateRowprep, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}, SCIP_SIDETYPE, Cuint), + scip, + rowprep, + sidetype, + _local, + ) end function SCIPfreeRowprep(scip, rowprep) - ccall((:SCIPfreeRowprep, libscip), Cvoid, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}), scip, rowprep) + ccall( + (:SCIPfreeRowprep, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}), + scip, + rowprep, + ) end function SCIPcopyRowprep(scip, target, source) - ccall((:SCIPcopyRowprep, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}, Ptr{SCIP_ROWPREP}), scip, target, source) + ccall( + (:SCIPcopyRowprep, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_ROWPREP}}, Ptr{SCIP_ROWPREP}), + scip, + target, + source, + ) end function SCIProwprepGetNVars(rowprep) @@ -20817,19 +60356,39 @@ function SCIProwprepGetNVars(rowprep) end function SCIProwprepGetVars(rowprep) - ccall((:SCIProwprepGetVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_ROWPREP},), rowprep) + ccall( + (:SCIProwprepGetVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_ROWPREP},), + rowprep, + ) end function SCIProwprepGetCoefs(rowprep) - ccall((:SCIProwprepGetCoefs, libscip), Ptr{Cdouble}, (Ptr{SCIP_ROWPREP},), rowprep) + ccall( + (:SCIProwprepGetCoefs, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_ROWPREP},), + rowprep, + ) end function SCIProwprepGetSide(rowprep) - ccall((:SCIProwprepGetSide, libscip), Cdouble, (Ptr{SCIP_ROWPREP},), rowprep) + ccall( + (:SCIProwprepGetSide, libscip), + Cdouble, + (Ptr{SCIP_ROWPREP},), + rowprep, + ) end function SCIProwprepGetSidetype(rowprep) - ccall((:SCIProwprepGetSidetype, libscip), SCIP_SIDETYPE, (Ptr{SCIP_ROWPREP},), rowprep) + ccall( + (:SCIProwprepGetSidetype, libscip), + SCIP_SIDETYPE, + (Ptr{SCIP_ROWPREP},), + rowprep, + ) end function SCIProwprepIsLocal(rowprep) @@ -20837,15 +60396,30 @@ function SCIProwprepIsLocal(rowprep) end function SCIProwprepGetName(rowprep) - ccall((:SCIProwprepGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_ROWPREP},), rowprep) + ccall( + (:SCIProwprepGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_ROWPREP},), + rowprep, + ) end function SCIProwprepGetNModifiedVars(rowprep) - ccall((:SCIProwprepGetNModifiedVars, libscip), Cint, (Ptr{SCIP_ROWPREP},), rowprep) + ccall( + (:SCIProwprepGetNModifiedVars, libscip), + Cint, + (Ptr{SCIP_ROWPREP},), + rowprep, + ) end function SCIProwprepGetModifiedVars(rowprep) - ccall((:SCIProwprepGetModifiedVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_ROWPREP},), rowprep) + ccall( + (:SCIProwprepGetModifiedVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_ROWPREP},), + rowprep, + ) end function SCIProwprepReset(rowprep) @@ -20853,2567 +60427,15884 @@ function SCIProwprepReset(rowprep) end function SCIProwprepSetCoef(rowprep, idx, newcoef) - ccall((:SCIProwprepSetCoef, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, Cint, Cdouble), rowprep, idx, newcoef) + ccall( + (:SCIProwprepSetCoef, libscip), + Cvoid, + (Ptr{SCIP_ROWPREP}, Cint, Cdouble), + rowprep, + idx, + newcoef, + ) end function SCIProwprepAddSide(rowprep, side) - ccall((:SCIProwprepAddSide, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, Cdouble), rowprep, side) + ccall( + (:SCIProwprepAddSide, libscip), + Cvoid, + (Ptr{SCIP_ROWPREP}, Cdouble), + rowprep, + side, + ) end function SCIProwprepAddConstant(rowprep, constant) - ccall((:SCIProwprepAddConstant, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, Cdouble), rowprep, constant) + ccall( + (:SCIProwprepAddConstant, libscip), + Cvoid, + (Ptr{SCIP_ROWPREP}, Cdouble), + rowprep, + constant, + ) end function SCIProwprepSetSidetype(rowprep, sidetype) - ccall((:SCIProwprepSetSidetype, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, SCIP_SIDETYPE), rowprep, sidetype) + ccall( + (:SCIProwprepSetSidetype, libscip), + Cvoid, + (Ptr{SCIP_ROWPREP}, SCIP_SIDETYPE), + rowprep, + sidetype, + ) end function SCIProwprepSetLocal(rowprep, islocal) - ccall((:SCIProwprepSetLocal, libscip), Cvoid, (Ptr{SCIP_ROWPREP}, Cuint), rowprep, islocal) + ccall( + (:SCIProwprepSetLocal, libscip), + Cvoid, + (Ptr{SCIP_ROWPREP}, Cuint), + rowprep, + islocal, + ) end function SCIProwprepRecordModifications(rowprep) - ccall((:SCIProwprepRecordModifications, libscip), Cvoid, (Ptr{SCIP_ROWPREP},), rowprep) + ccall( + (:SCIProwprepRecordModifications, libscip), + Cvoid, + (Ptr{SCIP_ROWPREP},), + rowprep, + ) end function SCIPprintRowprep(scip, rowprep, file) - ccall((:SCIPprintRowprep, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{Libc.FILE}), scip, rowprep, file) + ccall( + (:SCIPprintRowprep, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{Libc.FILE}), + scip, + rowprep, + file, + ) end function SCIPprintRowprepSol(scip, rowprep, sol, file) - ccall((:SCIPprintRowprepSol, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), scip, rowprep, sol, file) + ccall( + (:SCIPprintRowprepSol, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Ptr{Libc.FILE}), + scip, + rowprep, + sol, + file, + ) end function SCIPensureRowprepSize(scip, rowprep, size) - ccall((:SCIPensureRowprepSize, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cint), scip, rowprep, size) + ccall( + (:SCIPensureRowprepSize, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cint), + scip, + rowprep, + size, + ) end function SCIPaddRowprepTerm(scip, rowprep, var, coef) - ccall((:SCIPaddRowprepTerm, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_VAR}, Cdouble), scip, rowprep, var, coef) + ccall( + (:SCIPaddRowprepTerm, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_VAR}, Cdouble), + scip, + rowprep, + var, + coef, + ) end function SCIPaddRowprepTerms(scip, rowprep, nvars, vars, coefs) - ccall((:SCIPaddRowprepTerms, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), scip, rowprep, nvars, vars, coefs) + ccall( + (:SCIPaddRowprepTerms, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cint, Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}), + scip, + rowprep, + nvars, + vars, + coefs, + ) end function SCIPgetRowprepViolation(scip, rowprep, sol, reliable) - ccall((:SCIPgetRowprepViolation, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Ptr{Cuint}), scip, rowprep, sol, reliable) + ccall( + (:SCIPgetRowprepViolation, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Ptr{Cuint}), + scip, + rowprep, + sol, + reliable, + ) end function SCIPisRowprepViolationReliable(scip, rowprep, sol) - ccall((:SCIPisRowprepViolationReliable, libscip), Cuint, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}), scip, rowprep, sol) + ccall( + (:SCIPisRowprepViolationReliable, libscip), + Cuint, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}), + scip, + rowprep, + sol, + ) end function SCIPmergeRowprepTerms(scip, rowprep) - ccall((:SCIPmergeRowprepTerms, libscip), Cvoid, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}), scip, rowprep) + ccall( + (:SCIPmergeRowprepTerms, libscip), + Cvoid, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}), + scip, + rowprep, + ) end function SCIPcleanupRowprep(scip, rowprep, sol, minviol, viol, success) - ccall((:SCIPcleanupRowprep, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Cdouble, Ptr{Cdouble}, Ptr{Cuint}), scip, rowprep, sol, minviol, viol, success) + ccall( + (:SCIPcleanupRowprep, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP}, + Ptr{SCIP_ROWPREP}, + Ptr{SCIP_SOL}, + Cdouble, + Ptr{Cdouble}, + Ptr{Cuint}, + ), + scip, + rowprep, + sol, + minviol, + viol, + success, + ) end function SCIPcleanupRowprep2(scip, rowprep, sol, maxcoefbound, success) - ccall((:SCIPcleanupRowprep2, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Cdouble, Ptr{Cuint}), scip, rowprep, sol, maxcoefbound, success) + ccall( + (:SCIPcleanupRowprep2, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SOL}, Cdouble, Ptr{Cuint}), + scip, + rowprep, + sol, + maxcoefbound, + success, + ) end function SCIPscaleupRowprep(scip, rowprep, minscaleup, success) - ccall((:SCIPscaleupRowprep, libscip), Cdouble, (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cdouble, Ptr{Cuint}), scip, rowprep, minscaleup, success) + ccall( + (:SCIPscaleupRowprep, libscip), + Cdouble, + (Ptr{SCIP}, Ptr{SCIP_ROWPREP}, Cdouble, Ptr{Cuint}), + scip, + rowprep, + minscaleup, + success, + ) end function SCIPscaleRowprep(rowprep, factor) - ccall((:SCIPscaleRowprep, libscip), Cint, (Ptr{SCIP_ROWPREP}, Cdouble), rowprep, factor) + ccall( + (:SCIPscaleRowprep, libscip), + Cint, + (Ptr{SCIP_ROWPREP}, Cdouble), + rowprep, + factor, + ) end function SCIPgetRowprepRowConshdlr(scip, row, rowprep, conshdlr) - ccall((:SCIPgetRowprepRowConshdlr, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_CONSHDLR}), scip, row, rowprep, conshdlr) + ccall( + (:SCIPgetRowprepRowConshdlr, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_CONSHDLR}), + scip, + row, + rowprep, + conshdlr, + ) end function SCIPgetRowprepRowCons(scip, row, rowprep, cons) - ccall((:SCIPgetRowprepRowCons, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_CONS}), scip, row, rowprep, cons) + ccall( + (:SCIPgetRowprepRowCons, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_CONS}), + scip, + row, + rowprep, + cons, + ) end function SCIPgetRowprepRowSepa(scip, row, rowprep, sepa) - ccall((:SCIPgetRowprepRowSepa, libscip), SCIP_RETCODE, (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SEPA}), scip, row, rowprep, sepa) + ccall( + (:SCIPgetRowprepRowSepa, libscip), + SCIP_RETCODE, + (Ptr{SCIP}, Ptr{Ptr{SCIP_ROW}}, Ptr{SCIP_ROWPREP}, Ptr{SCIP_SEPA}), + scip, + row, + rowprep, + sepa, + ) end 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) + 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) + 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) + 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) + 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) + 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{Cuint}, 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{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, weights, capacity, len, medianpos) + ccall( + (:SCIPselectPtrBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, 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{Cuint}, + 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) + 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) + 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 SCIPselectPtrRealRealBoolBool( + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + k, + len, +) + ccall( + (:SCIPselectPtrRealRealBoolBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Cint, + Cint, + ), + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + k, + len, + ) +end + +function SCIPselectPtrRealRealIntBool( + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + k, + len, +) + ccall( + (:SCIPselectPtrRealRealIntBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Cint, + Cint, + ), + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + 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 SCIPselectWeightedPtrRealRealBoolBool( + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + weights, + capacity, + len, + medianpos, +) + ccall( + (:SCIPselectWeightedPtrRealRealBoolBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + weights, + capacity, + len, + medianpos, + ) +end + +function SCIPselectWeightedPtrRealRealIntBool( + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + weights, + capacity, + len, + medianpos, +) + ccall( + (:SCIPselectWeightedPtrRealRealIntBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + weights, + capacity, + len, + medianpos, + ) 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) +function SCIPselectPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, k, len) + ccall( + (:SCIPselectPtrRealBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, + Ptr{Cvoid}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + ptrarray, + realarray, + boolarray, + 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) +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 SCIPselectPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, k, len) - ccall((:SCIPselectPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, k, len) +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{Cuint}, + 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{Cuint}, + 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 SCIPselectPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, k, len) - ccall((:SCIPselectPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, k, len) +function SCIPselectReal(realarray, k, len) + ccall( + (:SCIPselectReal, libscip), + Cvoid, + (Ptr{Cdouble}, Cint, Cint), + realarray, + 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) +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 SCIPselectWeightedPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, weights, capacity, len, medianpos) +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 SCIPselectWeightedPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +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 SCIPselectPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, k, len) - ccall((:SCIPselectPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray, realarray, boolarray, ptrcomp, k, len) +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 SCIPselectWeightedPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +function SCIPselectRealBoolPtr(realarray, boolarray, ptrarray, k, len) + ccall( + (:SCIPselectRealBoolPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + realarray, + boolarray, + ptrarray, + 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) +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 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) +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 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) +function SCIPselectRealPtrPtr(realarray, ptrarray1, ptrarray2, k, len) + ccall( + (:SCIPselectRealPtrPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint), + realarray, + ptrarray1, + ptrarray2, + k, + len, + ) +end + +function SCIPselectWeightedRealPtrPtr( + realarray, + ptrarray1, + ptrarray2, + weights, + capacity, + len, + medianpos, +) + ccall( + (:SCIPselectWeightedRealPtrPtr, 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 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) +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{Cuint}, + 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + realarray1, + realarray2, + realarray3, + boolarray1, + boolarray2, + ptrarray, + 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) +function SCIPselectInt(intarray, k, len) + ccall( + (:SCIPselectInt, libscip), + Cvoid, + (Ptr{Cint}, Cint, Cint), + intarray, + 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) +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 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) +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 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) +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 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) +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 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) +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 SCIPselectPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) - ccall((:SCIPselectPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Cint), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, k, len) +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 SCIPselectWeightedPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, weights, capacity, len, medianpos) +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 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) +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 SCIPselectIntIntPtrPtr( + intarray1, + intarray2, + ptrarray1, + ptrarray2, + k, + len, +) + ccall( + (:SCIPselectIntIntPtrPtr, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint), + intarray1, + intarray2, + ptrarray1, + ptrarray2, + k, + len, + ) +end + +function SCIPselectIntIntPtrPtrInterval( + intarray1, + intarray2, + ptrarray1, + ptrarray2, + intervalarray, + k, + len, +) + ccall( + (:SCIPselectIntIntPtrPtrInterval, libscip), + Cvoid, + ( + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cvoid}}, + Ptr{Ptr{Cvoid}}, + Ptr{SCIP_INTERVAL}, + Cint, + Cint, + ), + intarray1, + intarray2, + ptrarray1, + ptrarray2, + intervalarray, + 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 SCIPselectWeightedIntIntPtrPtr( + intarray1, + intarray2, + ptrarray1, + ptrarray2, + weights, + capacity, + len, + medianpos, +) + ccall( + (:SCIPselectWeightedIntIntPtrPtr, libscip), + Cvoid, + ( + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cvoid}}, + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + intarray1, + intarray2, + ptrarray1, + ptrarray2, + weights, + capacity, + len, + medianpos, + ) +end + +function SCIPselectWeightedIntIntPtrPtrInterval( + intarray1, + intarray2, + ptrarray1, + ptrarray2, + intervalarray, + weights, + capacity, + len, + medianpos, +) + ccall( + (:SCIPselectWeightedIntIntPtrPtrInterval, libscip), + Cvoid, + ( + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cvoid}}, + Ptr{Ptr{Cvoid}}, + Ptr{SCIP_INTERVAL}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + intarray1, + intarray2, + ptrarray1, + ptrarray2, + intervalarray, + weights, + capacity, + len, + medianpos, + ) 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) +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 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) +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 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) +function SCIPselectLong(longarray, k, len) + ccall( + (:SCIPselectLong, libscip), + Cvoid, + (Ptr{Clonglong}, Cint, Cint), + longarray, + k, + len, + ) end -function SCIPselectReal(realarray, k, len) - ccall((:SCIPselectReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Cint), realarray, k, len) +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 SCIPselectWeightedReal(realarray, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedReal, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, weights, capacity, len, medianpos) +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 SCIPselectRealPtr(realarray, ptrarray, k, len) - ccall((:SCIPselectRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, ptrarray, k, len) +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{Cuint}, 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + intarray1, + ptrarray, + intarray2, + intarray3, + boolarray1, + boolarray2, + weights, + capacity, + len, + medianpos, + ) 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) +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 SCIPselectRealInt(realarray, intarray, k, len) - ccall((:SCIPselectRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), realarray, intarray, k, len) +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 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) +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 SCIPselectRealIntInt(realarray, intarray1, intarray2, k, len) - ccall((:SCIPselectRealIntInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint, Cint), realarray, intarray1, intarray2, k, len) +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 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) +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 SCIPselectRealBoolPtr(realarray, boolarray, ptrarray, k, len) - ccall((:SCIPselectRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, boolarray, ptrarray, k, len) +function SCIPselectDownPtrBool(ptrarray, boolarray, ptrcomp, k, len) + ccall( + (:SCIPselectDownPtrBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, 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{Cuint}, + 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{Cuint}, 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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 SCIPselectWeightedRealBoolPtr(realarray, boolarray, ptrarray, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, weights, capacity, len, medianpos) +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 SCIPselectRealIntLong(realarray, intarray, longarray, k, len) - ccall((:SCIPselectRealIntLong, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint, Cint), realarray, intarray, longarray, k, len) +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 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) +function SCIPselectDownRealInt(realarray, intarray, k, len) + ccall( + (:SCIPselectDownRealInt, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Cint, Cint), + realarray, + intarray, + k, + len, + ) 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) +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 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) +function SCIPselectDownRealBoolPtr(realarray, boolarray, ptrarray, k, len) + ccall( + (:SCIPselectDownRealBoolPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + realarray, + boolarray, + ptrarray, + weights, + capacity, + len, + medianpos, + ) end -function SCIPselectRealPtrPtr(realarray, ptrarray1, ptrarray2, k, len) - ccall((:SCIPselectRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray, ptrarray1, ptrarray2, k, len) +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 SCIPselectWeightedRealPtrPtr(realarray, ptrarray1, ptrarray2, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, weights, capacity, len, medianpos) +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 SCIPselectRealRealPtr(realarray1, realarray2, ptrarray, k, len) - ccall((:SCIPselectRealRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, ptrarray, k, len) +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 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) +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 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) +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{Cuint}, + 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + realarray1, + realarray2, + realarray3, + boolarray1, + boolarray2, + ptrarray, + weights, + capacity, + len, + medianpos, + ) 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) +function SCIPselectDownInt(intarray, k, len) + ccall( + (:SCIPselectDownInt, libscip), + Cvoid, + (Ptr{Cint}, Cint, Cint), + intarray, + k, + len, + ) 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) +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 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) +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 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) +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 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) +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 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) +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 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) +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 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) +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 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) +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 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) +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 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) +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 SCIPselectRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) - ccall((:SCIPselectRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Cint), realarray1, realarray2, realarray3, boolarray, ptrarray, k, len) +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{Cuint}, 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cdouble}, + Cdouble, + Cint, + Ptr{Cint}, + ), + intarray1, + ptrarray, + intarray2, + intarray3, + boolarray1, + boolarray2, + weights, + capacity, + len, + medianpos, + ) end -function SCIPselectWeightedRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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 SCIPselectIntIntPtrPtr(intarray1, intarray2, ptrarray1, ptrarray2, k, len) - ccall((:SCIPselectIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint), intarray1, intarray2, ptrarray1, ptrarray2, k, len) -end - -function SCIPselectIntIntPtrPtrInterval(intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, k, len) - ccall((:SCIPselectIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Cint, Cint), intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, 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 SCIPselectWeightedIntIntPtrPtr(intarray1, intarray2, ptrarray1, ptrarray2, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, weights, capacity, len, medianpos) -end - -function SCIPselectWeightedIntIntPtrPtrInterval(intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, weights, capacity, len, medianpos) - ccall((:SCIPselectWeightedIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, weights, capacity, len, medianpos) -end - -function SCIPsortCompInt(elem1, elem2) - ccall((:SCIPsortCompInt, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) -end - -function SCIPsortArgsortInt(dataptr, ind1, ind2) - ccall((:SCIPsortArgsortInt, libscip), Cint, (Ptr{Cvoid}, Cint, Cint), dataptr, ind1, ind2) -end - -function SCIPsortArgsortPtr(dataptr, ind1, ind2) - ccall((:SCIPsortArgsortPtr, libscip), Cint, (Ptr{Cvoid}, Cint, Cint), dataptr, ind1, ind2) -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{Cuint}, 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 SCIPsortPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, len) - ccall((:SCIPsortPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, len) -end - -function SCIPsortPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, len) - ccall((:SCIPsortPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, len) -end - -function SCIPsortPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) - ccall((:SCIPsortPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint), ptrarray, realarray, boolarray, 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{Cuint}, 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{Cuint}, 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 SCIPsortRealPtrPtr(realarray, ptrarray1, ptrarray2, len) - ccall((:SCIPsortRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), realarray, ptrarray1, ptrarray2, 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{Cuint}, 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{Cuint}, Ptr{Cuint}, 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 SCIPsortIntIntPtrPtr(intarray1, intarray2, ptrarray, ptrarray2, len) - ccall((:SCIPsortIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), intarray1, intarray2, ptrarray, ptrarray2, len) -end - -function SCIPsortIntIntPtrPtrInterval(intarray1, intarray2, ptrarray, ptrarray2, intervalarray, len) - ccall((:SCIPsortIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Cint), intarray1, intarray2, ptrarray, ptrarray2, intervalarray, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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 SCIPsortDownRealPtrPtr(realarray, ptrarray1, ptrarray2, len) - ccall((:SCIPsortDownRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), realarray, ptrarray1, ptrarray2, 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 SCIPsortDownRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, len) - ccall((:SCIPsortDownRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cuint, 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 SCIPsortedvecInsertPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) - ccall((:SCIPsortedvecInsertPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cdouble, Cuint, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) -end - -function SCIPsortedvecInsertPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) - ccall((:SCIPsortedvecInsertPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cdouble, Cint, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) -end - -function SCIPsortedvecInsertPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, keyval, field1val, field2val, len, pos) - ccall((:SCIPsortedvecInsertPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cuint, 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{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cuint, 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{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cuint, 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 SCIPsortedvecInsertRealPtrPtr(realarray, ptrarray1, ptrarray2, keyval, field1val, field2val, len, pos) - ccall((:SCIPsortedvecInsertRealPtrPtr, 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 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{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Cuint, 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{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Cuint, Cuint, 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 SCIPsortedvecInsertIntIntPtrPtr(intarray1, intarray2, ptrarray1, ptrarray2, keyval, field1val, field2val, field3val, len, pos) - ccall((:SCIPsortedvecInsertIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, keyval, field1val, field2val, field3val, len, pos) -end - -function SCIPsortedvecInsertIntIntPtrPtrInterval(intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, keyval, field1val, field2val, field3val, field4val, len, pos) - ccall((:SCIPsortedvecInsertIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Cint, Cint, Ptr{Cvoid}, Ptr{Cvoid}, SCIP_INTERVAL, Ptr{Cint}, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, keyval, field1val, field2val, field3val, field4val, 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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cuint, 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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cuint, 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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cint, Cuint, 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{Cuint}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, Cuint, 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{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Cuint, Cuint, 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{Cuint}, Ptr{Cuint}, Cint, Ptr{Cvoid}, Cint, Cint, Cuint, Cuint, 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{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cuint, 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{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cuint, 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{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Cdouble, Cuint, 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) +function SCIPsortCompInt(elem1, elem2) + ccall( + (:SCIPsortCompInt, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) 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) +function SCIPsortArgsortInt(dataptr, ind1, ind2) + ccall( + (:SCIPsortArgsortInt, libscip), + Cint, + (Ptr{Cvoid}, Cint, Cint), + dataptr, + ind1, + ind2, + ) end -function SCIPsortedvecInsertDownReal(realarray, keyval, len, pos) - ccall((:SCIPsortedvecInsertDownReal, libscip), Cvoid, (Ptr{Cdouble}, Cdouble, Ptr{Cint}, Ptr{Cint}), realarray, keyval, len, pos) +function SCIPsortArgsortPtr(dataptr, ind1, ind2) + ccall( + (:SCIPsortArgsortPtr, libscip), + Cint, + (Ptr{Cvoid}, Cint, Cint), + dataptr, + ind1, + ind2, + ) end -function SCIPsortedvecInsertDownRealBoolPtr(realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) - ccall((:SCIPsortedvecInsertDownRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray, boolarray, ptrarray, keyval, field1val, field2val, len, pos) +function SCIPsort(perm, indcomp, dataptr, len) + ccall( + (:SCIPsort, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), + perm, + indcomp, + dataptr, + len, + ) 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) +function SCIPsortInd(indarray, indcomp, dataptr, len) + ccall( + (:SCIPsortInd, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), + indarray, + indcomp, + dataptr, + len, + ) 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) +function SCIPsortPtr(ptrarray, ptrcomp, len) + ccall( + (:SCIPsortPtr, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), + ptrarray, + ptrcomp, + len, + ) 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) +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 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) +function SCIPsortPtrReal(ptrarray, realarray, ptrcomp, len) + ccall( + (:SCIPsortPtrReal, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), + ptrarray, + realarray, + ptrcomp, + len, + ) 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) +function SCIPsortPtrInt(ptrarray, intarray, ptrcomp, len) + ccall( + (:SCIPsortPtrInt, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), + ptrarray, + intarray, + ptrcomp, + len, + ) 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) +function SCIPsortPtrBool(ptrarray, boolarray, ptrcomp, len) + ccall( + (:SCIPsortPtrBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint), + ptrarray, + boolarray, + ptrcomp, + len, + ) 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) +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 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) +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 SCIPsortPtrRealRealBoolBool( + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + len, +) + ccall( + (:SCIPsortPtrRealRealBoolBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Cint, + ), + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + len, + ) +end + +function SCIPsortPtrRealRealIntBool( + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + len, +) + ccall( + (:SCIPsortPtrRealRealIntBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Cint, + ), + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + len, + ) 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) +function SCIPsortPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) + ccall( + (:SCIPsortPtrRealBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint), + ptrarray, + realarray, + boolarray, + ptrcomp, + len, + ) 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) +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 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) +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{Cuint}, + 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 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) +function SCIPsortReal(realarray, len) + ccall((:SCIPsortReal, libscip), Cvoid, (Ptr{Cdouble}, Cint), realarray, len) 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) +function SCIPsortRealPtr(realarray, ptrarray, len) + ccall( + (:SCIPsortRealPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), + realarray, + ptrarray, + len, + ) 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) +function SCIPsortRealInt(realarray, intarray, len) + ccall( + (:SCIPsortRealInt, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Cint), + realarray, + intarray, + len, + ) 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) +function SCIPsortRealIntInt(realarray, intarray1, intarray2, len) + ccall( + (:SCIPsortRealIntInt, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), + realarray, + intarray1, + intarray2, + len, + ) 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{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, keyval, field1val, field2val, field3val, field4val, len, pos) +function SCIPsortRealBoolPtr(realarray, boolarray, ptrarray, len) + ccall( + (:SCIPsortRealBoolPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), + realarray, + boolarray, + ptrarray, + len, + ) 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{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cdouble, Cdouble, Cdouble, Cuint, Cuint, Ptr{Cvoid}, Ptr{Cint}, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +function SCIPsortRealIntLong(realarray, intarray, longarray, len) + ccall( + (:SCIPsortRealIntLong, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint), + realarray, + intarray, + longarray, + len, + ) end -function SCIPsortedvecInsertDownInt(intarray, keyval, len, pos) - ccall((:SCIPsortedvecInsertDownInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}, Ptr{Cint}), intarray, keyval, len, pos) +function SCIPsortRealIntPtr(realarray, intarray, ptrarray, len) + ccall( + (:SCIPsortRealIntPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), + realarray, + intarray, + ptrarray, + len, + ) 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) +function SCIPsortRealPtrPtr(realarray, ptrarray1, ptrarray2, len) + ccall( + (:SCIPsortRealPtrPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), + realarray, + ptrarray1, + ptrarray2, + len, + ) 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) +function SCIPsortRealRealPtr(realarray1, realarray2, ptrarray, len) + ccall( + (:SCIPsortRealRealPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), + realarray1, + realarray2, + ptrarray, + len, + ) 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) +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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Ptr{Cvoid}}, + Cint, + ), + realarray1, + realarray2, + realarray3, + boolarray1, + boolarray2, + ptrarray, + len, + ) 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) +function SCIPsortInt(intarray, len) + ccall((:SCIPsortInt, libscip), Cvoid, (Ptr{Cint}, Cint), intarray, len) 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) +function SCIPsortIntInt(intarray1, intarray2, len) + ccall( + (:SCIPsortIntInt, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Cint), + intarray1, + intarray2, + len, + ) 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) +function SCIPsortIntPtr(intarray, ptrarray, len) + ccall( + (:SCIPsortIntPtr, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), + intarray, + ptrarray, + len, + ) 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) +function SCIPsortIntReal(intarray, realarray, len) + ccall( + (:SCIPsortIntReal, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cdouble}, Cint), + intarray, + realarray, + len, + ) 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) +function SCIPsortIntIntInt(intarray1, intarray2, intarray3, len) + ccall( + (:SCIPsortIntIntInt, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint), + intarray1, + intarray2, + intarray3, + len, + ) 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) +function SCIPsortIntIntLong(intarray1, intarray2, longarray, len) + ccall( + (:SCIPsortIntIntLong, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint), + intarray1, + intarray2, + longarray, + len, + ) 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) +function SCIPsortIntRealLong(intarray, realarray, longarray, len) + ccall( + (:SCIPsortIntRealLong, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Cint), + intarray, + realarray, + longarray, + len, + ) end -function SCIPsortedvecInsertDownLong(longarray, keyval, len, pos) - ccall((:SCIPsortedvecInsertDownLong, libscip), Cvoid, (Ptr{Clonglong}, Clonglong, Ptr{Cint}, Ptr{Cint}), longarray, keyval, len, pos) +function SCIPsortIntIntPtr(intarray1, intarray2, ptrarray, len) + ccall( + (:SCIPsortIntIntPtr, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), + intarray1, + intarray2, + ptrarray, + len, + ) 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) +function SCIPsortIntIntReal(intarray1, intarray2, realarray, len) + ccall( + (:SCIPsortIntIntReal, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint), + intarray1, + intarray2, + realarray, + len, + ) 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) +function SCIPsortIntPtrReal(intarray, ptrarray, realarray, len) + ccall( + (:SCIPsortIntPtrReal, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Cint), + intarray, + ptrarray, + realarray, + len, + ) 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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, keyval, field1val, field2val, field3val, len, pos) +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 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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, keyval, field1val, field2val, field3val, field4val, len, pos) +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 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{Cuint}, Clonglong, Ptr{Cvoid}, Cdouble, Cdouble, Cint, Cuint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +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 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) +function SCIPsortIntIntPtrPtr(intarray1, intarray2, ptrarray, ptrarray2, len) + ccall( + (:SCIPsortIntIntPtrPtr, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint), + intarray1, + intarray2, + ptrarray, + ptrarray2, + len, + ) +end + +function SCIPsortIntIntPtrPtrInterval( + intarray1, + intarray2, + ptrarray, + ptrarray2, + intervalarray, + len, +) + ccall( + (:SCIPsortIntIntPtrPtrInterval, libscip), + Cvoid, + ( + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cvoid}}, + Ptr{Ptr{Cvoid}}, + Ptr{SCIP_INTERVAL}, + Cint, + ), + intarray1, + intarray2, + ptrarray, + ptrarray2, + intervalarray, + len, + ) 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) +function SCIPsortLong(longarray, len) + ccall( + (:SCIPsortLong, libscip), + Cvoid, + (Ptr{Clonglong}, Cint), + longarray, + len, + ) 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{Cuint}, Ptr{Cint}, Clonglong, Ptr{Cvoid}, Ptr{Cvoid}, Cuint, Cint, Ptr{Cint}, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, keyval, field1val, field2val, field3val, field4val, len, pos) +function SCIPsortLongPtr(longarray, ptrarray, len) + ccall( + (:SCIPsortLongPtr, libscip), + Cvoid, + (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint), + longarray, + ptrarray, + len, + ) 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{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, keyval, field1val, field2val, field3val, field4val, len, pos) +function SCIPsortLongPtrInt(longarray, ptrarray, intarray, len) + ccall( + (:SCIPsortLongPtrInt, libscip), + Cvoid, + (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cint}, Cint), + longarray, + ptrarray, + intarray, + len, + ) 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{Cuint}, Ptr{Cuint}, Cint, Ptr{Cvoid}, Cint, Cint, Cuint, Cuint, Ptr{Cint}, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, keyval, field1val, field2val, field3val, field4val, field5val, len, pos) +function SCIPsortLongPtrRealBool(longarray, ptrarray, realarray, boolarray, len) + ccall( + (:SCIPsortLongPtrRealBool, libscip), + Cvoid, + (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, 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{Cuint}, + 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{Cuint}, + Cint, + ), + longarray, + ptrarray, + realarray, + realarray2, + intarray, + boolarray, + len, + ) 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) +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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Cint, + ), + intarray1, + ptrarray, + intarray2, + intarray3, + boolarray1, + boolarray2, + len, + ) end -function SCIPsortedvecDelPosPtr(ptrarray, ptrcomp, pos, len) - ccall((:SCIPsortedvecDelPosPtr, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, pos, len) +function SCIPsortDown(perm, indcomp, dataptr, len) + ccall( + (:SCIPsortDown, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), + perm, + indcomp, + dataptr, + 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) +function SCIPsortDownInd(indarray, indcomp, dataptr, len) + ccall( + (:SCIPsortDownInd, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint), + indarray, + indcomp, + dataptr, + 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) +function SCIPsortDownPtr(ptrarray, ptrcomp, len) + ccall( + (:SCIPsortDownPtr, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), + ptrarray, + ptrcomp, + 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) +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 SCIPsortedvecDelPosPtrBool(ptrarray, boolarray, ptrcomp, pos, len) - ccall((:SCIPsortedvecDelPosPtrBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, boolarray, ptrcomp, pos, len) +function SCIPsortDownPtrReal(ptrarray, realarray, ptrcomp, len) + ccall( + (:SCIPsortDownPtrReal, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cvoid}, Cint), + ptrarray, + realarray, + ptrcomp, + 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) +function SCIPsortDownPtrInt(ptrarray, intarray, ptrcomp, len) + ccall( + (:SCIPsortDownPtrInt, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cint}, Ptr{Cvoid}, Cint), + ptrarray, + intarray, + ptrcomp, + 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) +function SCIPsortDownPtrBool(ptrarray, boolarray, ptrcomp, len) + ccall( + (:SCIPsortDownPtrBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cvoid}, Cint), + ptrarray, + boolarray, + ptrcomp, + 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) +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 SCIPsortedvecDelPosPtrRealRealBoolBool(ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, pos, len) - ccall((:SCIPsortedvecDelPosPtrRealRealBoolBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, boolarray1, boolarray2, ptrcomp, pos, len) +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 SCIPsortedvecDelPosPtrRealRealIntBool(ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, pos, len) - ccall((:SCIPsortedvecDelPosPtrRealRealIntBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray1, realarray2, intarray, boolarray, ptrcomp, pos, len) +function SCIPsortDownPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, len) + ccall( + (:SCIPsortDownPtrRealBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint), + ptrarray, + realarray, + boolarray, + ptrcomp, + len, + ) end -function SCIPsortedvecDelPosPtrRealBool(ptrarray, realarray, boolarray, ptrcomp, pos, len) - ccall((:SCIPsortedvecDelPosPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, realarray, boolarray, ptrcomp, pos, len) +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 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) +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{Cuint}, + 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 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) +function SCIPsortDownReal(realarray, len) + ccall( + (:SCIPsortDownReal, libscip), + Cvoid, + (Ptr{Cdouble}, Cint), + realarray, + 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) +function SCIPsortDownRealPtr(realarray, ptrarray, len) + ccall( + (:SCIPsortDownRealPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint), + realarray, + ptrarray, + 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) +function SCIPsortDownRealInt(realarray, intarray, len) + ccall( + (:SCIPsortDownRealInt, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Cint), + realarray, + intarray, + 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) +function SCIPsortDownRealIntInt(realarray, intarray1, intarray2, len) + ccall( + (:SCIPsortDownRealIntInt, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Cint), + realarray, + intarray1, + intarray2, + len, + ) end -function SCIPsortedvecDelPosPtrPtrRealBool(ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) - ccall((:SCIPsortedvecDelPosPtrPtrRealBool, libscip), Cvoid, (Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray1, ptrarray2, realarray, boolarray, ptrcomp, pos, len) +function SCIPsortDownRealBoolPtr(realarray, boolarray, ptrarray, len) + ccall( + (:SCIPsortDownRealBoolPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint), + realarray, + boolarray, + ptrarray, + 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) +function SCIPsortDownRealIntLong(realarray, intarray, longarray, len) + ccall( + (:SCIPsortDownRealIntLong, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Ptr{Clonglong}, Cint), + realarray, + intarray, + longarray, + 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) +function SCIPsortDownRealIntPtr(realarray, intarray, ptrarray, len) + ccall( + (:SCIPsortDownRealIntPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), + realarray, + intarray, + ptrarray, + len, + ) end -function SCIPsortedvecDelPosRealBoolPtr(realarray, boolarray, ptrarray, pos, len) - ccall((:SCIPsortedvecDelPosRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, pos, len) +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 SCIPsortedvecDelPosRealPtr(realarray, ptrarray, pos, len) - ccall((:SCIPsortedvecDelPosRealPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, ptrarray, pos, len) +function SCIPsortDownRealRealInt(realarray1, realarray2, intarray, len) + ccall( + (:SCIPsortDownRealRealInt, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Cint), + realarray1, + realarray2, + intarray, + len, + ) end -function SCIPsortedvecDelPosReal(realarray, pos, len) - ccall((:SCIPsortedvecDelPosReal, libscip), Cvoid, (Ptr{Cdouble}, Cint, Ptr{Cint}), realarray, pos, len) +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 SCIPsortDownRealRealRealBoolPtr( + realarray1, + realarray2, + realarray3, + boolarray, + ptrarray, + len, +) + ccall( + (:SCIPsortDownRealRealRealBoolPtr, libscip), + Cvoid, + ( + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Ptr{Cvoid}}, + Cint, + ), + realarray1, + realarray2, + realarray3, + boolarray1, + boolarray2, + ptrarray, + len, + ) end -function SCIPsortedvecDelPosRealInt(realarray, intarray, pos, len) - ccall((:SCIPsortedvecDelPosRealInt, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cint}, Cint, Ptr{Cint}), realarray, intarray, pos, len) +function SCIPsortDownInt(intarray, len) + ccall((:SCIPsortDownInt, libscip), Cvoid, (Ptr{Cint}, Cint), intarray, 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) +function SCIPsortDownIntInt(intarray1, intarray2, len) + ccall( + (:SCIPsortDownIntInt, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Cint), + intarray1, + intarray2, + 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) +function SCIPsortDownIntPtr(intarray, ptrarray, len) + ccall( + (:SCIPsortDownIntPtr, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), + intarray, + ptrarray, + 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) +function SCIPsortDownIntReal(intarray, realarray, len) + ccall( + (:SCIPsortDownIntReal, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cdouble}, Cint), + intarray, + realarray, + len, + ) end -function SCIPsortedvecDelPosRealPtrPtr(realarray, ptrarray1, ptrarray2, pos, len) - ccall((:SCIPsortedvecDelPosRealPtrPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, ptrarray1, ptrarray2, pos, len) +function SCIPsortDownIntIntInt(intarray1, intarray2, intarray3, len) + ccall( + (:SCIPsortDownIntIntInt, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint), + intarray1, + intarray2, + intarray3, + 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) +function SCIPsortDownIntIntLong(intarray1, intarray2, longarray, len) + ccall( + (:SCIPsortDownIntIntLong, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Clonglong}, Cint), + intarray1, + intarray2, + longarray, + 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) +function SCIPsortDownIntIntPtr(intarray1, intarray2, ptrarray, len) + ccall( + (:SCIPsortDownIntIntPtr, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint), + intarray1, + intarray2, + ptrarray, + 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) +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 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) +function SCIPsortDownLong(longarray, len) + ccall( + (:SCIPsortDownLong, libscip), + Cvoid, + (Ptr{Clonglong}, Cint), + longarray, + 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) +function SCIPsortDownLongPtr(longarray, ptrarray, len) + ccall( + (:SCIPsortDownLongPtr, libscip), + Cvoid, + (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint), + longarray, + ptrarray, + 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) +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{Cuint}, 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Cint, + ), + intarray1, + ptrarray, + intarray2, + intarray3, + boolarray1, + boolarray2, + 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) +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 SCIPsortedvecDelPosRealRealRealBoolPtr(realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) - ccall((:SCIPsortedvecDelPosRealRealRealBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray, ptrarray, pos, len) +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{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cuint, + 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 SCIPsortedvecInsertPtrRealRealBoolBool( + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + keyval, + field1val, + field2val, + field3val, + field4val, + len, + pos, +) + ccall( + (:SCIPsortedvecInsertPtrRealRealBoolBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cdouble, + Cdouble, + Cuint, + Cuint, + Ptr{Cint}, + Ptr{Cint}, + ), + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + keyval, + field1val, + field2val, + field3val, + field4val, + len, + pos, + ) +end + +function SCIPsortedvecInsertPtrRealRealIntBool( + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + keyval, + field1val, + field2val, + field3val, + field4val, + len, + pos, +) + ccall( + (:SCIPsortedvecInsertPtrRealRealIntBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cdouble, + Cdouble, + Cint, + Cuint, + Ptr{Cint}, + Ptr{Cint}, + ), + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + keyval, + field1val, + field2val, + field3val, + field4val, + len, + pos, + ) +end + +function SCIPsortedvecInsertPtrRealBool( + ptrarray, + realarray, + boolarray, + ptrcomp, + keyval, + field1val, + field2val, + len, + pos, +) + ccall( + (:SCIPsortedvecInsertPtrRealBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cdouble, + Cuint, + 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{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cdouble, + Cuint, + 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{Cuint}, + Ptr{Ptr{Cvoid}}, + Cdouble, + Cuint, + 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 SCIPsortedvecDelPosRealRealRealBoolBoolPtr(realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, len) - ccall((:SCIPsortedvecDelPosRealRealRealBoolBoolPtr, libscip), Cvoid, (Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, pos, len) +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 SCIPsortedvecInsertRealPtrPtr( + realarray, + ptrarray1, + ptrarray2, + keyval, + field1val, + field2val, + len, + pos, +) + ccall( + (:SCIPsortedvecInsertRealPtrPtr, 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 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{Cuint}, + Ptr{Ptr{Cvoid}}, + Cdouble, + Cdouble, + Cdouble, + Cuint, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Ptr{Cvoid}}, + Cdouble, + Cdouble, + Cdouble, + Cuint, + Cuint, + Ptr{Cvoid}, + Ptr{Cint}, + Ptr{Cint}, + ), + realarray1, + realarray2, + realarray3, + boolarray1, + boolarray2, + ptrarray, + keyval, + field1val, + field2val, + field3val, + field4val, + field5val, + len, + pos, + ) end -function SCIPsortedvecDelPosInt(intarray, pos, len) - ccall((:SCIPsortedvecDelPosInt, libscip), Cvoid, (Ptr{Cint}, Cint, Ptr{Cint}), intarray, pos, len) +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 SCIPsortedvecInsertIntIntPtrPtr( + intarray1, + intarray2, + ptrarray1, + ptrarray2, + keyval, + field1val, + field2val, + field3val, + len, + pos, +) + ccall( + (:SCIPsortedvecInsertIntIntPtrPtr, libscip), + Cvoid, + ( + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cvoid}}, + Ptr{Ptr{Cvoid}}, + Cint, + Cint, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cint}, + Ptr{Cint}, + ), + intarray1, + intarray2, + ptrarray1, + ptrarray2, + keyval, + field1val, + field2val, + field3val, + len, + pos, + ) +end + +function SCIPsortedvecInsertIntIntPtrPtrInterval( + intarray1, + intarray2, + ptrarray1, + ptrarray2, + intervalarray, + keyval, + field1val, + field2val, + field3val, + field4val, + len, + pos, +) + ccall( + (:SCIPsortedvecInsertIntIntPtrPtrInterval, libscip), + Cvoid, + ( + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cvoid}}, + Ptr{Ptr{Cvoid}}, + Ptr{SCIP_INTERVAL}, + Cint, + Cint, + Ptr{Cvoid}, + Ptr{Cvoid}, + SCIP_INTERVAL, + Ptr{Cint}, + Ptr{Cint}, + ), + intarray1, + intarray2, + ptrarray1, + ptrarray2, + intervalarray, + keyval, + field1val, + field2val, + field3val, + field4val, + 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 SCIPsortedvecDelPosIntInt(intarray1, intarray2, pos, len) - ccall((:SCIPsortedvecDelPosIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), intarray1, intarray2, pos, len) +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{Cuint}, + Clonglong, + Ptr{Cvoid}, + Cdouble, + Cuint, + 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{Cuint}, + Clonglong, + Ptr{Cvoid}, + Cdouble, + Cdouble, + Cuint, + 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{Cuint}, + Clonglong, + Ptr{Cvoid}, + Cdouble, + Cdouble, + Cint, + Cuint, + 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{Cuint}, + Ptr{Cint}, + Clonglong, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cuint, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cint, + Cint, + Cuint, + Cuint, + 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{Cuint}, + Ptr{Cuint}, + Cint, + Ptr{Cvoid}, + Cint, + Cint, + Cuint, + Cuint, + 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 SCIPsortedvecDelPosIntReal(intarray, realarray, pos, len) - ccall((:SCIPsortedvecDelPosIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray, realarray, pos, len) +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{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cuint, + 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{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cdouble, + Cuint, + 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{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cdouble, + Cuint, + 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 SCIPsortedvecDelPosIntIntInt(intarray1, intarray2, intarray3, pos, len) - ccall((:SCIPsortedvecDelPosIntIntInt, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), intarray1, intarray2, intarray3, pos, len) +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{Cuint}, + Ptr{Ptr{Cvoid}}, + Cdouble, + Cuint, + 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 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 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 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{Cuint}, + Ptr{Ptr{Cvoid}}, + Cdouble, + Cdouble, + Cdouble, + Cuint, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Ptr{Cvoid}}, + Cdouble, + Cdouble, + Cdouble, + Cuint, + Cuint, + Ptr{Cvoid}, + Ptr{Cint}, + Ptr{Cint}, + ), + realarray1, + realarray2, + realarray3, + boolarray1, + boolarray2, + ptrarray, + keyval, + field1val, + field2val, + field3val, + field4val, + field5val, + len, + pos, + ) 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) +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 SCIPsortedvecDelPosIntRealLong(intarray, realarray, longarray, pos, len) - ccall((:SCIPsortedvecDelPosIntRealLong, libscip), Cvoid, (Ptr{Cint}, Ptr{Cdouble}, Ptr{Clonglong}, Cint, Ptr{Cint}), intarray, realarray, longarray, pos, len) +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{Cuint}, + Clonglong, + Ptr{Cvoid}, + Cdouble, + Cuint, + 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{Cuint}, + Clonglong, + Ptr{Cvoid}, + Cdouble, + Cdouble, + Cuint, + 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{Cuint}, + Clonglong, + Ptr{Cvoid}, + Cdouble, + Cdouble, + Cint, + Cuint, + 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{Cuint}, + Ptr{Cint}, + Clonglong, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cuint, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Ptr{Cvoid}, + Cint, + Cint, + Cuint, + Cuint, + 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{Cuint}, + Ptr{Cuint}, + Cint, + Ptr{Cvoid}, + Cint, + Cint, + Cuint, + Cuint, + Ptr{Cint}, + Ptr{Cint}, + ), + intarray1, + ptrarray, + intarray2, + intarray3, + boolarray1, + boolarray2, + keyval, + field1val, + field2val, + field3val, + field4val, + field5val, + len, + pos, + ) 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) +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 SCIPsortedvecDelPosIntIntPtrPtr(intarray1, intarray2, ptrarray1, ptrarray2, pos, len) - ccall((:SCIPsortedvecDelPosIntIntPtrPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, pos, len) +function SCIPsortedvecDelPosPtr(ptrarray, ptrcomp, pos, len) + ccall( + (:SCIPsortedvecDelPosPtr, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint, Ptr{Cint}), + ptrarray, + ptrcomp, + pos, + len, + ) end -function SCIPsortedvecDelPosIntIntPtrPtrInterval(intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, pos, len) - ccall((:SCIPsortedvecDelPosIntIntPtrPtrInterval, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{SCIP_INTERVAL}, Cint, Ptr{Cint}), intarray1, intarray2, ptrarray1, ptrarray2, intervalarray, pos, len) +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 SCIPsortedvecDelPosIntIntReal(intarray1, intarray2, realarray, pos, len) - ccall((:SCIPsortedvecDelPosIntIntReal, libscip), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), intarray1, intarray2, realarray, pos, len) +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 SCIPsortedvecDelPosIntPtr(intarray, ptrarray, pos, len) - ccall((:SCIPsortedvecDelPosIntPtr, libscip), Cvoid, (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), intarray, ptrarray, pos, len) +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 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) +function SCIPsortedvecDelPosPtrBool(ptrarray, boolarray, ptrcomp, pos, len) + ccall( + (:SCIPsortedvecDelPosPtrBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, 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 SCIPsortedvecDelPosPtrRealRealBoolBool( + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + pos, + len, +) + ccall( + (:SCIPsortedvecDelPosPtrRealRealBoolBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Cint, + Ptr{Cint}, + ), + ptrarray, + realarray1, + realarray2, + boolarray1, + boolarray2, + ptrcomp, + pos, + len, + ) +end + +function SCIPsortedvecDelPosPtrRealRealIntBool( + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + pos, + len, +) + ccall( + (:SCIPsortedvecDelPosPtrRealRealIntBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cuint}, + Ptr{Cvoid}, + Cint, + Ptr{Cint}, + ), + ptrarray, + realarray1, + realarray2, + intarray, + boolarray, + ptrcomp, + pos, + len, + ) +end + +function SCIPsortedvecDelPosPtrRealBool( + ptrarray, + realarray, + boolarray, + ptrcomp, + pos, + len, +) + ccall( + (:SCIPsortedvecDelPosPtrRealBool, libscip), + Cvoid, + ( + Ptr{Ptr{Cvoid}}, + Ptr{Cdouble}, + Ptr{Cuint}, + 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{Cuint}, + 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{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), + realarray, + boolarray, + ptrarray, + 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) +function SCIPsortedvecDelPosRealPtr(realarray, ptrarray, pos, len) + ccall( + (:SCIPsortedvecDelPosRealPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), + realarray, + 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) +function SCIPsortedvecDelPosReal(realarray, pos, len) + ccall( + (:SCIPsortedvecDelPosReal, libscip), + Cvoid, + (Ptr{Cdouble}, Cint, Ptr{Cint}), + 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) +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 SCIPsortedvecDelPosLong(longarray, pos, len) - ccall((:SCIPsortedvecDelPosLong, libscip), Cvoid, (Ptr{Clonglong}, Cint, Ptr{Cint}), longarray, pos, len) +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 SCIPsortedvecDelPosRealPtrPtr( + realarray, + ptrarray1, + ptrarray2, + pos, + len, +) + ccall( + (:SCIPsortedvecDelPosRealPtrPtr, libscip), + Cvoid, + (Ptr{Cdouble}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), + realarray, + ptrarray1, + ptrarray2, + 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Ptr{Ptr{Cvoid}}, + Cint, + Ptr{Cint}, + ), + realarray1, + realarray2, + realarray3, + boolarray1, + boolarray2, + ptrarray, + 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) +function SCIPsortedvecDelPosInt(intarray, pos, len) + ccall( + (:SCIPsortedvecDelPosInt, libscip), + Cvoid, + (Ptr{Cint}, Cint, Ptr{Cint}), + intarray, + 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) +function SCIPsortedvecDelPosIntInt(intarray1, intarray2, pos, len) + ccall( + (:SCIPsortedvecDelPosIntInt, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cint}, Cint, Ptr{Cint}), + intarray1, + intarray2, + pos, + len, + ) end -function SCIPsortedvecDelPosLongPtrRealBool(longarray, ptrarray, realarray, boolarray, pos, len) - ccall((:SCIPsortedvecDelPosLongPtrRealBool, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Cdouble}, Ptr{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, boolarray, pos, len) +function SCIPsortedvecDelPosIntReal(intarray, realarray, pos, len) + ccall( + (:SCIPsortedvecDelPosIntReal, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}), + intarray, + realarray, + 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{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, boolarray, pos, len) +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 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{Cuint}, Cint, Ptr{Cint}), longarray, ptrarray, realarray, realarray2, intarray, boolarray, pos, len) +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 SCIPsortedvecDelPosIntIntPtrPtr( + intarray1, + intarray2, + ptrarray1, + ptrarray2, + pos, + len, +) + ccall( + (:SCIPsortedvecDelPosIntIntPtrPtr, libscip), + Cvoid, + ( + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cvoid}}, + Ptr{Ptr{Cvoid}}, + Cint, + Ptr{Cint}, + ), + intarray1, + intarray2, + ptrarray1, + ptrarray2, + pos, + len, + ) +end + +function SCIPsortedvecDelPosIntIntPtrPtrInterval( + intarray1, + intarray2, + ptrarray1, + ptrarray2, + intervalarray, + pos, + len, +) + ccall( + (:SCIPsortedvecDelPosIntIntPtrPtrInterval, libscip), + Cvoid, + ( + Ptr{Cint}, + Ptr{Cint}, + Ptr{Ptr{Cvoid}}, + Ptr{Ptr{Cvoid}}, + Ptr{SCIP_INTERVAL}, + Cint, + Ptr{Cint}, + ), + intarray1, + intarray2, + ptrarray1, + ptrarray2, + intervalarray, + 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 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) +function SCIPsortedvecDelPosIntPtr(intarray, ptrarray, pos, len) + ccall( + (:SCIPsortedvecDelPosIntPtr, libscip), + Cvoid, + (Ptr{Cint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), + intarray, + ptrarray, + 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) +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 SCIPsortedvecDelPosLongPtrPtrBoolInt(longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) - ccall((:SCIPsortedvecDelPosLongPtrPtrBoolInt, libscip), Cvoid, (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Ptr{Ptr{Cvoid}}, Ptr{Cuint}, Ptr{Cint}, Cint, Ptr{Cint}), longarray, ptrarray1, ptrarray2, boolarray, intarray, pos, len) +function SCIPsortedvecDelPosLong(longarray, pos, len) + ccall( + (:SCIPsortedvecDelPosLong, libscip), + Cvoid, + (Ptr{Clonglong}, Cint, Ptr{Cint}), + longarray, + 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{Cuint}, Ptr{Cuint}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, intarray1, intarray2, boolarray1, boolarray2, ptrcomp, pos, len) +function SCIPsortedvecDelPosLongPtr(longarray, ptrarray, pos, len) + ccall( + (:SCIPsortedvecDelPosLongPtr, libscip), + Cvoid, + (Ptr{Clonglong}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), + longarray, + ptrarray, + 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{Cuint}, Ptr{Cuint}, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, pos, len) +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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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) + 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) + 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) + 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) + 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) + 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{Cuint}, 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{Cuint}, 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{Cuint}, 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) + ccall( + (:SCIPsortedvecDelPosDownPtrBool, libscip), + Cvoid, + (Ptr{Ptr{Cvoid}}, Ptr{Cuint}, 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{Cuint}, + 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{Cuint}, + 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{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray, boolarray, ptrarray, 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{Cuint}, 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) + 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 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 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 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{Cuint}, 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{Cuint}, Ptr{Cuint}, Ptr{Ptr{Cvoid}}, Cint, Ptr{Cint}), realarray1, realarray2, realarray3, boolarray1, boolarray2, ptrarray, 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 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 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 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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) + 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) + 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) + 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) + 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) + 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, 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{Cuint}, Ptr{Cuint}, 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{Cuint}, Ptr{Cuint}, Cint, Ptr{Cint}), intarray1, ptrarray, intarray2, intarray3, boolarray1, boolarray2, 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + 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{Cuint}, + Ptr{Cuint}, + Cint, + Ptr{Cint}, + ), + intarray1, + ptrarray, + intarray2, + intarray3, + boolarray1, + boolarray2, + pos, + len, + ) end function SCIPsortedvecFindInd(indarray, indcomp, dataptr, val, len, pos) - ccall((:SCIPsortedvecFindInd, libscip), Cuint, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}), indarray, indcomp, dataptr, val, len, pos) + ccall( + (:SCIPsortedvecFindInd, libscip), + Cuint, + (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), Cuint, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, val, len, pos) + ccall( + (:SCIPsortedvecFindPtr, libscip), + Cuint, + (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), Cuint, (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, val, len, pos) + ccall( + (:SCIPsortedvecFindReal, libscip), + Cuint, + (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), + realarray, + val, + len, + pos, + ) end function SCIPsortedvecFindInt(intarray, val, len, pos) - ccall((:SCIPsortedvecFindInt, libscip), Cuint, (Ptr{Cint}, Cint, Cint, Ptr{Cint}), intarray, val, len, pos) + ccall( + (:SCIPsortedvecFindInt, libscip), + Cuint, + (Ptr{Cint}, Cint, Cint, Ptr{Cint}), + intarray, + val, + len, + pos, + ) end function SCIPsortedvecFindLong(longarray, val, len, pos) - ccall((:SCIPsortedvecFindLong, libscip), Cuint, (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), longarray, val, len, pos) + ccall( + (:SCIPsortedvecFindLong, libscip), + Cuint, + (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), + longarray, + val, + len, + pos, + ) end function SCIPsortedvecFindDownInd(indarray, indcomp, dataptr, val, len, pos) - ccall((:SCIPsortedvecFindDownInd, libscip), Cuint, (Ptr{Cint}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Cint, Ptr{Cint}), indarray, indcomp, dataptr, val, len, pos) + ccall( + (:SCIPsortedvecFindDownInd, libscip), + Cuint, + (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), Cuint, (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{Cint}), ptrarray, ptrcomp, val, len, pos) + ccall( + (:SCIPsortedvecFindDownPtr, libscip), + Cuint, + (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), Cuint, (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), realarray, val, len, pos) + ccall( + (:SCIPsortedvecFindDownReal, libscip), + Cuint, + (Ptr{Cdouble}, Cdouble, Cint, Ptr{Cint}), + realarray, + val, + len, + pos, + ) end function SCIPsortedvecFindDownInt(intarray, val, len, pos) - ccall((:SCIPsortedvecFindDownInt, libscip), Cuint, (Ptr{Cint}, Cint, Cint, Ptr{Cint}), intarray, val, len, pos) + ccall( + (:SCIPsortedvecFindDownInt, libscip), + Cuint, + (Ptr{Cint}, Cint, Cint, Ptr{Cint}), + intarray, + val, + len, + pos, + ) end function SCIPsortedvecFindDownLong(longarray, val, len, pos) - ccall((:SCIPsortedvecFindDownLong, libscip), Cuint, (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), longarray, val, len, pos) + ccall( + (:SCIPsortedvecFindDownLong, libscip), + Cuint, + (Ptr{Clonglong}, Clonglong, Cint, Ptr{Cint}), + longarray, + val, + len, + pos, + ) end const SCIP_Netmatdec = Cvoid @@ -23421,87 +76312,264 @@ const SCIP_Netmatdec = Cvoid const SCIP_NETMATDEC = SCIP_Netmatdec function SCIPnetmatdecCreate(blkmem, pdec, nrows, ncols) - ccall((:SCIPnetmatdecCreate, libscip), SCIP_RETCODE, (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_NETMATDEC}}, Cint, Cint), blkmem, pdec, nrows, ncols) + ccall( + (:SCIPnetmatdecCreate, libscip), + SCIP_RETCODE, + (Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_NETMATDEC}}, Cint, Cint), + blkmem, + pdec, + nrows, + ncols, + ) end function SCIPnetmatdecFree(pdec) - ccall((:SCIPnetmatdecFree, libscip), Cvoid, (Ptr{Ptr{SCIP_NETMATDEC}},), pdec) -end - -function SCIPnetmatdecTryAddCol(dec, column, nonzrows, nonzvals, nnonzs, success) - ccall((:SCIPnetmatdecTryAddCol, libscip), SCIP_RETCODE, (Ptr{SCIP_NETMATDEC}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cuint}), dec, column, nonzrows, nonzvals, nnonzs, success) + ccall( + (:SCIPnetmatdecFree, libscip), + Cvoid, + (Ptr{Ptr{SCIP_NETMATDEC}},), + pdec, + ) +end + +function SCIPnetmatdecTryAddCol( + dec, + column, + nonzrows, + nonzvals, + nnonzs, + success, +) + ccall( + (:SCIPnetmatdecTryAddCol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NETMATDEC}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cuint}), + dec, + column, + nonzrows, + nonzvals, + nnonzs, + success, + ) end function SCIPnetmatdecTryAddRow(dec, row, nonzcols, nonzvals, nnonzs, success) - ccall((:SCIPnetmatdecTryAddRow, libscip), SCIP_RETCODE, (Ptr{SCIP_NETMATDEC}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cuint}), dec, row, nonzcols, nonzvals, nnonzs, success) + ccall( + (:SCIPnetmatdecTryAddRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NETMATDEC}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cuint}), + dec, + row, + nonzcols, + nonzvals, + nnonzs, + success, + ) end function SCIPnetmatdecContainsRow(dec, row) - ccall((:SCIPnetmatdecContainsRow, libscip), Cuint, (Ptr{SCIP_NETMATDEC}, Cint), dec, row) + ccall( + (:SCIPnetmatdecContainsRow, libscip), + Cuint, + (Ptr{SCIP_NETMATDEC}, Cint), + dec, + row, + ) end function SCIPnetmatdecContainsColumn(dec, column) - ccall((:SCIPnetmatdecContainsColumn, libscip), Cuint, (Ptr{SCIP_NETMATDEC}, Cint), dec, column) -end - -function SCIPnetmatdecRemoveComponent(dec, componentrows, nrows, componentcols, ncols) - ccall((:SCIPnetmatdecRemoveComponent, libscip), Cvoid, (Ptr{SCIP_NETMATDEC}, Ptr{Cint}, Cint, Ptr{Cint}, Cint), dec, componentrows, nrows, componentcols, ncols) + ccall( + (:SCIPnetmatdecContainsColumn, libscip), + Cuint, + (Ptr{SCIP_NETMATDEC}, Cint), + dec, + column, + ) +end + +function SCIPnetmatdecRemoveComponent( + dec, + componentrows, + nrows, + componentcols, + ncols, +) + ccall( + (:SCIPnetmatdecRemoveComponent, libscip), + Cvoid, + (Ptr{SCIP_NETMATDEC}, Ptr{Cint}, Cint, Ptr{Cint}, Cint), + dec, + componentrows, + nrows, + componentcols, + ncols, + ) end function SCIPnetmatdecIsMinimal(dec) - ccall((:SCIPnetmatdecIsMinimal, libscip), Cuint, (Ptr{SCIP_NETMATDEC},), dec) -end - -function SCIPnetmatdecVerifyCycle(bufmem, dec, column, nonzrowidx, nonzvals, nnonzs, pathrowstorage, pathsignstorage) - ccall((:SCIPnetmatdecVerifyCycle, libscip), Cuint, (Ptr{BMS_BUFMEM}, Ptr{SCIP_NETMATDEC}, Cint, Ptr{Cint}, Ptr{Cdouble}, Cint, Ptr{Cint}, Ptr{Cuint}), bufmem, dec, column, nonzrowidx, nonzvals, nnonzs, pathrowstorage, pathsignstorage) + ccall( + (:SCIPnetmatdecIsMinimal, libscip), + Cuint, + (Ptr{SCIP_NETMATDEC},), + dec, + ) +end + +function SCIPnetmatdecVerifyCycle( + bufmem, + dec, + column, + nonzrowidx, + nonzvals, + nnonzs, + pathrowstorage, + pathsignstorage, +) + ccall( + (:SCIPnetmatdecVerifyCycle, libscip), + Cuint, + ( + Ptr{BMS_BUFMEM}, + Ptr{SCIP_NETMATDEC}, + Cint, + Ptr{Cint}, + Ptr{Cdouble}, + Cint, + Ptr{Cint}, + Ptr{Cuint}, + ), + bufmem, + dec, + column, + nonzrowidx, + nonzvals, + nnonzs, + pathrowstorage, + pathsignstorage, + ) end function SCIPnetmatdecCreateDiGraph(dec, blkmem, pdigraph, createrowarcs) - ccall((:SCIPnetmatdecCreateDiGraph, libscip), SCIP_RETCODE, (Ptr{SCIP_NETMATDEC}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_DIGRAPH}}, Cuint), dec, blkmem, pdigraph, createrowarcs) + ccall( + (:SCIPnetmatdecCreateDiGraph, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NETMATDEC}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_DIGRAPH}}, Cuint), + dec, + blkmem, + pdigraph, + createrowarcs, + ) end function SCIPnlhdlrSetCopyHdlr(nlhdlr, copy) - ccall((:SCIPnlhdlrSetCopyHdlr, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), nlhdlr, copy) + ccall( + (:SCIPnlhdlrSetCopyHdlr, libscip), + Cvoid, + (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), + nlhdlr, + copy, + ) end function SCIPnlhdlrSetFreeHdlrData(nlhdlr, freehdlrdata) - ccall((:SCIPnlhdlrSetFreeHdlrData, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), nlhdlr, freehdlrdata) + ccall( + (:SCIPnlhdlrSetFreeHdlrData, libscip), + Cvoid, + (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), + nlhdlr, + freehdlrdata, + ) end function SCIPnlhdlrSetFreeExprData(nlhdlr, freeexprdata) - ccall((:SCIPnlhdlrSetFreeExprData, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), nlhdlr, freeexprdata) + ccall( + (:SCIPnlhdlrSetFreeExprData, libscip), + Cvoid, + (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), + nlhdlr, + freeexprdata, + ) end function SCIPnlhdlrSetInitExit(nlhdlr, init, exit) - ccall((:SCIPnlhdlrSetInitExit, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), nlhdlr, init, exit) + ccall( + (:SCIPnlhdlrSetInitExit, libscip), + Cvoid, + (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), + nlhdlr, + init, + exit, + ) end function SCIPnlhdlrSetProp(nlhdlr, inteval, reverseprop) - ccall((:SCIPnlhdlrSetProp, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), nlhdlr, inteval, reverseprop) + ccall( + (:SCIPnlhdlrSetProp, libscip), + Cvoid, + (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}), + nlhdlr, + inteval, + reverseprop, + ) end function SCIPnlhdlrSetSepa(nlhdlr, initsepa, enfo, estimate, exitsepa) - ccall((:SCIPnlhdlrSetSepa, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), nlhdlr, initsepa, enfo, estimate, exitsepa) + ccall( + (:SCIPnlhdlrSetSepa, libscip), + Cvoid, + (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), + nlhdlr, + initsepa, + enfo, + estimate, + exitsepa, + ) end function SCIPnlhdlrSetSollinearize(nlhdlr, sollinearize) - ccall((:SCIPnlhdlrSetSollinearize, libscip), Cvoid, (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), nlhdlr, sollinearize) + ccall( + (:SCIPnlhdlrSetSollinearize, libscip), + Cvoid, + (Ptr{SCIP_NLHDLR}, Ptr{Cvoid}), + nlhdlr, + sollinearize, + ) end function SCIPnlhdlrGetName(nlhdlr) - ccall((:SCIPnlhdlrGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_NLHDLR},), nlhdlr) + ccall( + (:SCIPnlhdlrGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_NLHDLR},), + nlhdlr, + ) end function SCIPnlhdlrGetDesc(nlhdlr) - ccall((:SCIPnlhdlrGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_NLHDLR},), nlhdlr) + ccall( + (:SCIPnlhdlrGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_NLHDLR},), + nlhdlr, + ) end function SCIPnlhdlrGetDetectPriority(nlhdlr) - ccall((:SCIPnlhdlrGetDetectPriority, libscip), Cint, (Ptr{SCIP_NLHDLR},), nlhdlr) + ccall( + (:SCIPnlhdlrGetDetectPriority, libscip), + Cint, + (Ptr{SCIP_NLHDLR},), + nlhdlr, + ) end function SCIPnlhdlrGetEnfoPriority(nlhdlr) - ccall((:SCIPnlhdlrGetEnfoPriority, libscip), Cint, (Ptr{SCIP_NLHDLR},), nlhdlr) + ccall( + (:SCIPnlhdlrGetEnfoPriority, libscip), + Cint, + (Ptr{SCIP_NLHDLR},), + nlhdlr, + ) end function SCIPnlhdlrIsEnabled(nlhdlr) @@ -23509,7 +76577,12 @@ function SCIPnlhdlrIsEnabled(nlhdlr) end function SCIPnlhdlrGetData(nlhdlr) - ccall((:SCIPnlhdlrGetData, libscip), Ptr{SCIP_NLHDLRDATA}, (Ptr{SCIP_NLHDLR},), nlhdlr) + ccall( + (:SCIPnlhdlrGetData, libscip), + Ptr{SCIP_NLHDLRDATA}, + (Ptr{SCIP_NLHDLR},), + nlhdlr, + ) end function SCIPnlhdlrHasIntEval(nlhdlr) @@ -23517,7 +76590,12 @@ function SCIPnlhdlrHasIntEval(nlhdlr) end function SCIPnlhdlrHasReverseProp(nlhdlr) - ccall((:SCIPnlhdlrHasReverseProp, libscip), Cuint, (Ptr{SCIP_NLHDLR},), nlhdlr) + ccall( + (:SCIPnlhdlrHasReverseProp, libscip), + Cuint, + (Ptr{SCIP_NLHDLR},), + nlhdlr, + ) end function SCIPnlhdlrHasInitSepa(nlhdlr) @@ -23537,11 +76615,22 @@ function SCIPnlhdlrHasEstimate(nlhdlr) end function SCIPnlhdlrHasSollinearize(nlhdlr) - ccall((:SCIPnlhdlrHasSollinearize, libscip), Cuint, (Ptr{SCIP_NLHDLR},), nlhdlr) + ccall( + (:SCIPnlhdlrHasSollinearize, libscip), + Cuint, + (Ptr{SCIP_NLHDLR},), + nlhdlr, + ) end function SCIPnlhdlrComp(elem1, elem2) - ccall((:SCIPnlhdlrComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIPnlhdlrComp, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPnlrowGetConstant(nlrow) @@ -23553,15 +76642,30 @@ function SCIPnlrowGetNLinearVars(nlrow) end function SCIPnlrowGetLinearVars(nlrow) - ccall((:SCIPnlrowGetLinearVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_NLROW},), 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) + ccall( + (:SCIPnlrowGetLinearCoefs, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_NLROW},), + nlrow, + ) end function SCIPnlrowGetExpr(nlrow) - ccall((:SCIPnlrowGetExpr, libscip), Ptr{SCIP_EXPR}, (Ptr{SCIP_NLROW},), nlrow) + ccall( + (:SCIPnlrowGetExpr, libscip), + Ptr{SCIP_EXPR}, + (Ptr{SCIP_NLROW},), + nlrow, + ) end function SCIPnlrowGetLhs(nlrow) @@ -23573,7 +76677,12 @@ function SCIPnlrowGetRhs(nlrow) end function SCIPnlrowGetCurvature(nlrow) - ccall((:SCIPnlrowGetCurvature, libscip), SCIP_EXPRCURV, (Ptr{SCIP_NLROW},), nlrow) + ccall( + (:SCIPnlrowGetCurvature, libscip), + SCIP_EXPRCURV, + (Ptr{SCIP_NLROW},), + nlrow, + ) end function SCIPnlrowGetName(nlrow) @@ -23593,11 +76702,22 @@ function SCIPnlrowGetDualsol(nlrow) end function SCIPnlpiComp(elem1, elem2) - ccall((:SCIPnlpiComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), elem1, elem2) + ccall( + (:SCIPnlpiComp, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPnlpiGetData(nlpi) - ccall((:SCIPnlpiGetData, libscip), Ptr{SCIP_NLPIDATA}, (Ptr{SCIP_NLPI},), nlpi) + ccall( + (:SCIPnlpiGetData, libscip), + Ptr{SCIP_NLPIDATA}, + (Ptr{SCIP_NLPI},), + nlpi, + ) end function SCIPnlpiGetName(nlpi) @@ -23633,59 +76753,134 @@ function SCIPnlpiGetEvalTime(nlpi) end function SCIPnlpiGetNIterations(nlpi) - ccall((:SCIPnlpiGetNIterations, libscip), Clonglong, (Ptr{SCIP_NLPI},), nlpi) + ccall( + (:SCIPnlpiGetNIterations, libscip), + Clonglong, + (Ptr{SCIP_NLPI},), + nlpi, + ) end function SCIPnlpiGetNTermStat(nlpi, termstatus) - ccall((:SCIPnlpiGetNTermStat, libscip), Cint, (Ptr{SCIP_NLPI}, SCIP_NLPTERMSTAT), nlpi, termstatus) + ccall( + (:SCIPnlpiGetNTermStat, libscip), + Cint, + (Ptr{SCIP_NLPI}, SCIP_NLPTERMSTAT), + nlpi, + termstatus, + ) end function SCIPnlpiGetNSolStat(nlpi, solstatus) - ccall((:SCIPnlpiGetNSolStat, libscip), Cint, (Ptr{SCIP_NLPI}, SCIP_NLPSOLSTAT), nlpi, solstatus) + ccall( + (:SCIPnlpiGetNSolStat, libscip), + Cint, + (Ptr{SCIP_NLPI}, SCIP_NLPSOLSTAT), + nlpi, + solstatus, + ) end function SCIPnlpiMergeStatistics(targetnlpi, sourcenlpi, reset) - ccall((:SCIPnlpiMergeStatistics, libscip), Cvoid, (Ptr{SCIP_NLPI}, Ptr{SCIP_NLPI}, Cuint), targetnlpi, sourcenlpi, reset) + ccall( + (:SCIPnlpiMergeStatistics, libscip), + Cvoid, + (Ptr{SCIP_NLPI}, Ptr{SCIP_NLPI}, Cuint), + targetnlpi, + sourcenlpi, + reset, + ) end function SCIPnodeselGetName(nodesel) - ccall((:SCIPnodeselGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_NODESEL},), nodesel) + ccall( + (:SCIPnodeselGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_NODESEL},), + nodesel, + ) end function SCIPnodeselGetDesc(nodesel) - ccall((:SCIPnodeselGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_NODESEL},), nodesel) + ccall( + (:SCIPnodeselGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_NODESEL},), + nodesel, + ) end function SCIPnodeselGetStdPriority(nodesel) - ccall((:SCIPnodeselGetStdPriority, libscip), Cint, (Ptr{SCIP_NODESEL},), nodesel) + ccall( + (:SCIPnodeselGetStdPriority, libscip), + Cint, + (Ptr{SCIP_NODESEL},), + nodesel, + ) end function SCIPnodeselGetMemsavePriority(nodesel) - ccall((:SCIPnodeselGetMemsavePriority, libscip), Cint, (Ptr{SCIP_NODESEL},), nodesel) + ccall( + (:SCIPnodeselGetMemsavePriority, libscip), + Cint, + (Ptr{SCIP_NODESEL},), + nodesel, + ) end function SCIPnodeselGetData(nodesel) - ccall((:SCIPnodeselGetData, libscip), Ptr{SCIP_NODESELDATA}, (Ptr{SCIP_NODESEL},), 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) + ccall( + (:SCIPnodeselSetData, libscip), + Cvoid, + (Ptr{SCIP_NODESEL}, Ptr{SCIP_NODESELDATA}), + nodesel, + nodeseldata, + ) end function SCIPnodeselIsInitialized(nodesel) - ccall((:SCIPnodeselIsInitialized, libscip), Cuint, (Ptr{SCIP_NODESEL},), nodesel) + ccall( + (:SCIPnodeselIsInitialized, libscip), + Cuint, + (Ptr{SCIP_NODESEL},), + nodesel, + ) end function SCIPnodeselGetSetupTime(nodesel) - ccall((:SCIPnodeselGetSetupTime, libscip), Cdouble, (Ptr{SCIP_NODESEL},), nodesel) + ccall( + (:SCIPnodeselGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_NODESEL},), + nodesel, + ) end function SCIPnodeselGetTime(nodesel) - ccall((:SCIPnodeselGetTime, libscip), Cdouble, (Ptr{SCIP_NODESEL},), nodesel) + ccall( + (:SCIPnodeselGetTime, libscip), + Cdouble, + (Ptr{SCIP_NODESEL},), + nodesel, + ) end function SCIPparamGetType(param) - ccall((:SCIPparamGetType, libscip), SCIP_PARAMTYPE, (Ptr{SCIP_PARAM},), param) + ccall( + (:SCIPparamGetType, libscip), + SCIP_PARAMTYPE, + (Ptr{SCIP_PARAM},), + param, + ) end function SCIPparamGetName(param) @@ -23697,7 +76892,12 @@ function SCIPparamGetDesc(param) end function SCIPparamGetData(param) - ccall((:SCIPparamGetData, libscip), Ptr{SCIP_PARAMDATA}, (Ptr{SCIP_PARAM},), param) + ccall( + (:SCIPparamGetData, libscip), + Ptr{SCIP_PARAMDATA}, + (Ptr{SCIP_PARAM},), + param, + ) end function SCIPparamIsAdvanced(param) @@ -23709,7 +76909,13 @@ function SCIPparamIsFixed(param) end function SCIPparamSetFixed(param, fixed) - ccall((:SCIPparamSetFixed, libscip), Cvoid, (Ptr{SCIP_PARAM}, Cuint), param, fixed) + ccall( + (:SCIPparamSetFixed, libscip), + Cvoid, + (Ptr{SCIP_PARAM}, Cuint), + param, + fixed, + ) end function SCIPparamGetBool(param) @@ -23741,15 +76947,30 @@ function SCIPparamGetLongint(param) end function SCIPparamGetLongintMin(param) - ccall((:SCIPparamGetLongintMin, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) + ccall( + (:SCIPparamGetLongintMin, libscip), + Clonglong, + (Ptr{SCIP_PARAM},), + param, + ) end function SCIPparamGetLongintMax(param) - ccall((:SCIPparamGetLongintMax, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) + ccall( + (:SCIPparamGetLongintMax, libscip), + Clonglong, + (Ptr{SCIP_PARAM},), + param, + ) end function SCIPparamGetLongintDefault(param) - ccall((:SCIPparamGetLongintDefault, libscip), Clonglong, (Ptr{SCIP_PARAM},), param) + ccall( + (:SCIPparamGetLongintDefault, libscip), + Clonglong, + (Ptr{SCIP_PARAM},), + param, + ) end function SCIPparamGetReal(param) @@ -23765,7 +76986,12 @@ function SCIPparamGetRealMax(param) end function SCIPparamGetRealDefault(param) - ccall((:SCIPparamGetRealDefault, libscip), Cdouble, (Ptr{SCIP_PARAM},), param) + ccall( + (:SCIPparamGetRealDefault, libscip), + Cdouble, + (Ptr{SCIP_PARAM},), + param, + ) end function SCIPparamGetChar(param) @@ -23773,7 +76999,12 @@ function SCIPparamGetChar(param) end function SCIPparamGetCharAllowedValues(param) - ccall((:SCIPparamGetCharAllowedValues, libscip), Ptr{Cchar}, (Ptr{SCIP_PARAM},), param) + ccall( + (:SCIPparamGetCharAllowedValues, libscip), + Ptr{Cchar}, + (Ptr{SCIP_PARAM},), + param, + ) end function SCIPparamGetCharDefault(param) @@ -23785,7 +77016,12 @@ function SCIPparamGetString(param) end function SCIPparamGetStringDefault(param) - ccall((:SCIPparamGetStringDefault, libscip), Ptr{Cchar}, (Ptr{SCIP_PARAM},), param) + ccall( + (:SCIPparamGetStringDefault, libscip), + Ptr{Cchar}, + (Ptr{SCIP_PARAM},), + param, + ) end function SCIPparamIsDefault(param) @@ -23793,19 +77029,42 @@ function SCIPparamIsDefault(param) end function SCIPpresolComp(elem1, elem2) - ccall((:SCIPpresolComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPpresolCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPpresolGetData(presol) - ccall((:SCIPpresolGetData, libscip), Ptr{SCIP_PRESOLDATA}, (Ptr{SCIP_PRESOL},), 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) + ccall( + (:SCIPpresolSetData, libscip), + Cvoid, + (Ptr{SCIP_PRESOL}, Ptr{SCIP_PRESOLDATA}), + presol, + presoldata, + ) end function SCIPpresolMarkExact(presol) @@ -23813,11 +77072,21 @@ function SCIPpresolMarkExact(presol) end function SCIPpresolGetName(presol) - ccall((:SCIPpresolGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_PRESOL},), presol) + ccall( + (:SCIPpresolGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_PRESOL},), + presol, + ) end function SCIPpresolGetDesc(presol) - ccall((:SCIPpresolGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_PRESOL},), presol) + ccall( + (:SCIPpresolGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_PRESOL},), + presol, + ) end function SCIPpresolGetPriority(presol) @@ -23829,19 +77098,40 @@ function SCIPpresolGetMaxrounds(presol) end function SCIPpresolGetTiming(presol) - ccall((:SCIPpresolGetTiming, libscip), SCIP_PRESOLTIMING, (Ptr{SCIP_PRESOL},), 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) + ccall( + (:SCIPpresolSetTiming, libscip), + Cvoid, + (Ptr{SCIP_PRESOL}, SCIP_PRESOLTIMING), + presol, + timing, + ) end function SCIPpresolIsInitialized(presol) - ccall((:SCIPpresolIsInitialized, libscip), Cuint, (Ptr{SCIP_PRESOL},), presol) + ccall( + (:SCIPpresolIsInitialized, libscip), + Cuint, + (Ptr{SCIP_PRESOL},), + presol, + ) end function SCIPpresolGetSetupTime(presol) - ccall((:SCIPpresolGetSetupTime, libscip), Cdouble, (Ptr{SCIP_PRESOL},), presol) + ccall( + (:SCIPpresolGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_PRESOL},), + presol, + ) end function SCIPpresolGetTime(presol) @@ -23849,7 +77139,12 @@ function SCIPpresolGetTime(presol) end function SCIPpresolGetNFixedVars(presol) - ccall((:SCIPpresolGetNFixedVars, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) + ccall( + (:SCIPpresolGetNFixedVars, libscip), + Cint, + (Ptr{SCIP_PRESOL},), + presol, + ) end function SCIPpresolGetNAggrVars(presol) @@ -23857,7 +77152,12 @@ function SCIPpresolGetNAggrVars(presol) end function SCIPpresolGetNChgVarTypes(presol) - ccall((:SCIPpresolGetNChgVarTypes, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) + ccall( + (:SCIPpresolGetNChgVarTypes, libscip), + Cint, + (Ptr{SCIP_PRESOL},), + presol, + ) end function SCIPpresolGetNChgBds(presol) @@ -23877,7 +77177,12 @@ function SCIPpresolGetNAddConss(presol) end function SCIPpresolGetNUpgdConss(presol) - ccall((:SCIPpresolGetNUpgdConss, libscip), Cint, (Ptr{SCIP_PRESOL},), presol) + ccall( + (:SCIPpresolGetNUpgdConss, libscip), + Cint, + (Ptr{SCIP_PRESOL},), + presol, + ) end function SCIPpresolGetNChgCoefs(presol) @@ -23893,19 +77198,42 @@ function SCIPpresolGetNCalls(presol) end function SCIPpricerComp(elem1, elem2) - ccall((:SCIPpricerComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPpricerCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPpricerGetData(pricer) - ccall((:SCIPpricerGetData, libscip), Ptr{SCIP_PRICERDATA}, (Ptr{SCIP_PRICER},), 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) + ccall( + (:SCIPpricerSetData, libscip), + Cvoid, + (Ptr{SCIP_PRICER}, Ptr{SCIP_PRICERDATA}), + pricer, + pricerdata, + ) end function SCIPpricerMarkExact(pricer) @@ -23913,11 +77241,21 @@ function SCIPpricerMarkExact(pricer) end function SCIPpricerGetName(pricer) - ccall((:SCIPpricerGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_PRICER},), pricer) + ccall( + (:SCIPpricerGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_PRICER},), + pricer, + ) end function SCIPpricerGetDesc(pricer) - ccall((:SCIPpricerGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_PRICER},), pricer) + ccall( + (:SCIPpricerGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_PRICER},), + pricer, + ) end function SCIPpricerGetPriority(pricer) @@ -23929,11 +77267,21 @@ function SCIPpricerGetNCalls(pricer) end function SCIPpricerGetNVarsFound(pricer) - ccall((:SCIPpricerGetNVarsFound, libscip), Cint, (Ptr{SCIP_PRICER},), pricer) + ccall( + (:SCIPpricerGetNVarsFound, libscip), + Cint, + (Ptr{SCIP_PRICER},), + pricer, + ) end function SCIPpricerGetSetupTime(pricer) - ccall((:SCIPpricerGetSetupTime, libscip), Cdouble, (Ptr{SCIP_PRICER},), pricer) + ccall( + (:SCIPpricerGetSetupTime, libscip), + Cdouble, + (Ptr{SCIP_PRICER},), + pricer, + ) end function SCIPpricerGetTime(pricer) @@ -23949,27 +77297,61 @@ function SCIPpricerIsDelayed(pricer) end function SCIPpricerIsInitialized(pricer) - ccall((:SCIPpricerIsInitialized, libscip), Cuint, (Ptr{SCIP_PRICER},), pricer) + ccall( + (:SCIPpricerIsInitialized, libscip), + Cuint, + (Ptr{SCIP_PRICER},), + pricer, + ) end function SCIPpropComp(elem1, elem2) - ccall((:SCIPpropComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + 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) + ccall( + (:SCIPpropCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPpropGetData(prop) - ccall((:SCIPpropGetData, libscip), Ptr{SCIP_PROPDATA}, (Ptr{SCIP_PROP},), 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) + ccall( + (:SCIPpropSetData, libscip), + Cvoid, + (Ptr{SCIP_PROP}, Ptr{SCIP_PROPDATA}), + prop, + propdata, + ) end function SCIPpropMarkExact(prop) @@ -24001,7 +77383,13 @@ function SCIPpropGetSetupTime(prop) end function SCIPpropSetFreq(prop, freq) - ccall((:SCIPpropSetFreq, libscip), Cvoid, (Ptr{SCIP_PROP}, Cint), prop, freq) + ccall( + (:SCIPpropSetFreq, libscip), + Cvoid, + (Ptr{SCIP_PROP}, Cint), + prop, + freq, + ) end function SCIPpropGetTime(prop) @@ -24009,7 +77397,12 @@ function SCIPpropGetTime(prop) end function SCIPpropGetStrongBranchPropTime(prop) - ccall((:SCIPpropGetStrongBranchPropTime, libscip), Cdouble, (Ptr{SCIP_PROP},), prop) + ccall( + (:SCIPpropGetStrongBranchPropTime, libscip), + Cdouble, + (Ptr{SCIP_PROP},), + prop, + ) end function SCIPpropGetRespropTime(prop) @@ -24025,7 +77418,12 @@ function SCIPpropGetNCalls(prop) end function SCIPpropGetNRespropCalls(prop) - ccall((:SCIPpropGetNRespropCalls, libscip), Clonglong, (Ptr{SCIP_PROP},), prop) + ccall( + (:SCIPpropGetNRespropCalls, libscip), + Clonglong, + (Ptr{SCIP_PROP},), + prop, + ) end function SCIPpropGetNCutoffs(prop) @@ -24033,7 +77431,12 @@ function SCIPpropGetNCutoffs(prop) end function SCIPpropGetNDomredsFound(prop) - ccall((:SCIPpropGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_PROP},), prop) + ccall( + (:SCIPpropGetNDomredsFound, libscip), + Clonglong, + (Ptr{SCIP_PROP},), + prop, + ) end function SCIPpropIsDelayed(prop) @@ -24093,11 +77496,22 @@ function SCIPpropGetNPresolCalls(prop) end function SCIPpropGetTimingmask(prop) - ccall((:SCIPpropGetTimingmask, libscip), SCIP_PROPTIMING, (Ptr{SCIP_PROP},), prop) + ccall( + (:SCIPpropGetTimingmask, libscip), + SCIP_PROPTIMING, + (Ptr{SCIP_PROP},), + prop, + ) end function SCIPpropSetTimingmask(prop, timingmask) - ccall((:SCIPpropSetTimingmask, libscip), Cvoid, (Ptr{SCIP_PROP}, SCIP_PROPTIMING), prop, timingmask) + ccall( + (:SCIPpropSetTimingmask, libscip), + Cvoid, + (Ptr{SCIP_PROP}, SCIP_PROPTIMING), + prop, + timingmask, + ) end function SCIPpropDoesPresolve(prop) @@ -24105,19 +77519,41 @@ function SCIPpropDoesPresolve(prop) end function SCIPpropGetPresolTiming(prop) - ccall((:SCIPpropGetPresolTiming, libscip), SCIP_PRESOLTIMING, (Ptr{SCIP_PROP},), 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) + ccall( + (:SCIPpropSetPresolTiming, libscip), + Cvoid, + (Ptr{SCIP_PROP}, SCIP_PRESOLTIMING), + prop, + presoltiming, + ) end function SCIPreaderGetData(reader) - ccall((:SCIPreaderGetData, libscip), Ptr{SCIP_READERDATA}, (Ptr{SCIP_READER},), 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) + ccall( + (:SCIPreaderSetData, libscip), + Cvoid, + (Ptr{SCIP_READER}, Ptr{SCIP_READERDATA}), + reader, + readerdata, + ) end function SCIPreaderMarkExact(reader) @@ -24125,15 +77561,30 @@ function SCIPreaderMarkExact(reader) end function SCIPreaderGetName(reader) - ccall((:SCIPreaderGetName, libscip), Ptr{Cchar}, (Ptr{SCIP_READER},), reader) + ccall( + (:SCIPreaderGetName, libscip), + Ptr{Cchar}, + (Ptr{SCIP_READER},), + reader, + ) end function SCIPreaderGetDesc(reader) - ccall((:SCIPreaderGetDesc, libscip), Ptr{Cchar}, (Ptr{SCIP_READER},), reader) + ccall( + (:SCIPreaderGetDesc, libscip), + Ptr{Cchar}, + (Ptr{SCIP_READER},), + reader, + ) end function SCIPreaderGetExtension(reader) - ccall((:SCIPreaderGetExtension, libscip), Ptr{Cchar}, (Ptr{SCIP_READER},), reader) + ccall( + (:SCIPreaderGetExtension, libscip), + Ptr{Cchar}, + (Ptr{SCIP_READER},), + reader, + ) end function SCIPreaderCanRead(reader) @@ -24145,19 +77596,42 @@ function SCIPreaderCanWrite(reader) end function SCIPrelaxComp(elem1, elem2) - ccall((:SCIPrelaxComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPrelaxCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPrelaxGetData(relax) - ccall((:SCIPrelaxGetData, libscip), Ptr{SCIP_RELAXDATA}, (Ptr{SCIP_RELAX},), 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) + ccall( + (:SCIPrelaxSetData, libscip), + Cvoid, + (Ptr{SCIP_RELAX}, Ptr{SCIP_RELAXDATA}), + relax, + relaxdata, + ) end function SCIPrelaxMarkExact(relax) @@ -24193,27 +77667,57 @@ function SCIPrelaxGetNCalls(relax) end function SCIPrelaxGetNCutoffs(relax) - ccall((:SCIPrelaxGetNCutoffs, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) + ccall( + (:SCIPrelaxGetNCutoffs, libscip), + Clonglong, + (Ptr{SCIP_RELAX},), + relax, + ) end function SCIPrelaxGetNImprovedLowerbound(relax) - ccall((:SCIPrelaxGetNImprovedLowerbound, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) + ccall( + (:SCIPrelaxGetNImprovedLowerbound, libscip), + Clonglong, + (Ptr{SCIP_RELAX},), + relax, + ) end function SCIPrelaxGetImprovedLowerboundTime(relax) - ccall((:SCIPrelaxGetImprovedLowerboundTime, libscip), Cdouble, (Ptr{SCIP_RELAX},), relax) + ccall( + (:SCIPrelaxGetImprovedLowerboundTime, libscip), + Cdouble, + (Ptr{SCIP_RELAX},), + relax, + ) end function SCIPrelaxGetNAddedConss(relax) - ccall((:SCIPrelaxGetNAddedConss, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) + ccall( + (:SCIPrelaxGetNAddedConss, libscip), + Clonglong, + (Ptr{SCIP_RELAX},), + relax, + ) end function SCIPrelaxGetNReducedDomains(relax) - ccall((:SCIPrelaxGetNReducedDomains, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) + ccall( + (:SCIPrelaxGetNReducedDomains, libscip), + Clonglong, + (Ptr{SCIP_RELAX},), + relax, + ) end function SCIPrelaxGetNSeparatedCuts(relax) - ccall((:SCIPrelaxGetNSeparatedCuts, libscip), Clonglong, (Ptr{SCIP_RELAX},), relax) + ccall( + (:SCIPrelaxGetNSeparatedCuts, libscip), + Clonglong, + (Ptr{SCIP_RELAX},), + relax, + ) end function SCIPrelaxIsInitialized(relax) @@ -24225,51 +77729,134 @@ function SCIPrelaxMarkUnsolved(relax) end function SCIPreoptnodeGetNVars(reoptnode) - ccall((:SCIPreoptnodeGetNVars, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) + ccall( + (:SCIPreoptnodeGetNVars, libscip), + Cint, + (Ptr{SCIP_REOPTNODE},), + reoptnode, + ) end function SCIPreoptnodeGetNConss(reoptnode) - ccall((:SCIPreoptnodeGetNConss, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) + ccall( + (:SCIPreoptnodeGetNConss, libscip), + Cint, + (Ptr{SCIP_REOPTNODE},), + reoptnode, + ) end function SCIPreoptnodeGetNDualBoundChgs(reoptnode) - ccall((:SCIPreoptnodeGetNDualBoundChgs, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) + ccall( + (:SCIPreoptnodeGetNDualBoundChgs, libscip), + Cint, + (Ptr{SCIP_REOPTNODE},), + reoptnode, + ) end function SCIPreoptnodeGetNChildren(reoptnode) - ccall((:SCIPreoptnodeGetNChildren, libscip), Cint, (Ptr{SCIP_REOPTNODE},), reoptnode) + ccall( + (:SCIPreoptnodeGetNChildren, libscip), + Cint, + (Ptr{SCIP_REOPTNODE},), + reoptnode, + ) end function SCIPreoptnodeGetLowerbound(reoptnode) - ccall((:SCIPreoptnodeGetLowerbound, libscip), Cdouble, (Ptr{SCIP_REOPTNODE},), reoptnode) + ccall( + (:SCIPreoptnodeGetLowerbound, libscip), + Cdouble, + (Ptr{SCIP_REOPTNODE},), + reoptnode, + ) end function SCIPreoptnodeGetType(reoptnode) - ccall((:SCIPreoptnodeGetType, libscip), SCIP_REOPTTYPE, (Ptr{SCIP_REOPTNODE},), reoptnode) -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) + ccall( + (:SCIPreoptnodeGetType, libscip), + SCIP_REOPTTYPE, + (Ptr{SCIP_REOPTNODE},), + reoptnode, + ) +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}, Cuint), reoptnode, parentid) + ccall( + (:SCIPreoptnodeSetParentID, libscip), + Cvoid, + (Ptr{SCIP_REOPTNODE}, Cuint), + reoptnode, + parentid, + ) end function SCIPreoptGetNRestartsGlobal(reopt) - ccall((:SCIPreoptGetNRestartsGlobal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetNRestartsGlobal, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPreoptGetNRestartsLocal(reopt) - ccall((:SCIPreoptGetNRestartsLocal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetNRestartsLocal, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPreoptGetNTotalRestartsLocal(reopt) - ccall((:SCIPreoptGetNTotalRestartsLocal, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetNTotalRestartsLocal, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPreoptGetFirstRestarts(reopt) - ccall((:SCIPreoptGetFirstRestarts, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetFirstRestarts, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPreoptGetLastRestarts(reopt) @@ -24281,7 +77868,12 @@ function SCIPreoptGetNFeasNodes(reopt) end function SCIPreoptGetNTotalFeasNodes(reopt) - ccall((:SCIPreoptGetNTotalFeasNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetNTotalFeasNodes, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPreoptGetNPrunedNodes(reopt) @@ -24289,15 +77881,30 @@ function SCIPreoptGetNPrunedNodes(reopt) end function SCIPreoptGetNTotalPrunedNodes(reopt) - ccall((:SCIPreoptGetNTotalPrunedNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetNTotalPrunedNodes, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPreoptGetNCutoffReoptnodes(reopt) - ccall((:SCIPreoptGetNCutoffReoptnodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetNCutoffReoptnodes, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPreoptGetNTotalCutoffReoptnodes(reopt) - ccall((:SCIPreoptGetNTotalCutoffReoptnodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetNTotalCutoffReoptnodes, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPreoptGetNInfNodes(reopt) @@ -24305,23 +77912,51 @@ function SCIPreoptGetNInfNodes(reopt) end function SCIPreoptGetNTotalInfNodes(reopt) - ccall((:SCIPreoptGetNTotalInfNodes, libscip), Cint, (Ptr{SCIP_REOPT},), reopt) + ccall( + (:SCIPreoptGetNTotalInfNodes, libscip), + Cint, + (Ptr{SCIP_REOPT},), + reopt, + ) end function SCIPsepaComp(elem1, elem2) - ccall((:SCIPsepaComp, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPsepaCompName, libscip), + Cint, + (Ptr{Cvoid}, Ptr{Cvoid}), + elem1, + elem2, + ) end function SCIPsepaGetData(sepa) - ccall((:SCIPsepaGetData, libscip), Ptr{SCIP_SEPADATA}, (Ptr{SCIP_SEPA},), 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) + ccall( + (:SCIPsepaSetData, libscip), + Cvoid, + (Ptr{SCIP_SEPA}, Ptr{SCIP_SEPADATA}), + sepa, + sepadata, + ) end function SCIPsepaGetName(sepa) @@ -24341,7 +77976,13 @@ function SCIPsepaGetFreq(sepa) end function SCIPsepaSetFreq(sepa, freq) - ccall((:SCIPsepaSetFreq, libscip), Cvoid, (Ptr{SCIP_SEPA}, Cint), sepa, freq) + ccall( + (:SCIPsepaSetFreq, libscip), + Cvoid, + (Ptr{SCIP_SEPA}, Cint), + sepa, + freq, + ) end function SCIPsepaMarkExact(sepa) @@ -24389,35 +78030,75 @@ function SCIPsepaGetNCutsAdded(sepa) end function SCIPsepaGetNCutsAddedViaPool(sepa) - ccall((:SCIPsepaGetNCutsAddedViaPool, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetNCutsAddedViaPool, libscip), + Clonglong, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsepaGetNCutsAddedDirect(sepa) - ccall((:SCIPsepaGetNCutsAddedDirect, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetNCutsAddedDirect, libscip), + Clonglong, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsepaGetNCutsApplied(sepa) - ccall((:SCIPsepaGetNCutsApplied, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetNCutsApplied, libscip), + Clonglong, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsepaGetNCutsAppliedViaPool(sepa) - ccall((:SCIPsepaGetNCutsAppliedViaPool, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetNCutsAppliedViaPool, libscip), + Clonglong, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsepaGetNCutsAppliedDirect(sepa) - ccall((:SCIPsepaGetNCutsAppliedDirect, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetNCutsAppliedDirect, libscip), + Clonglong, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsepaGetNCutsFoundAtNode(sepa) - ccall((:SCIPsepaGetNCutsFoundAtNode, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetNCutsFoundAtNode, libscip), + Clonglong, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsepaGetNConssFound(sepa) - ccall((:SCIPsepaGetNConssFound, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetNConssFound, libscip), + Clonglong, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsepaGetNDomredsFound(sepa) - ccall((:SCIPsepaGetNDomredsFound, libscip), Clonglong, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetNDomredsFound, libscip), + Clonglong, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsepaIsDelayed(sepa) @@ -24441,7 +78122,12 @@ function SCIPsepaIsParentsepa(sepa) end function SCIPsepaGetParentsepa(sepa) - ccall((:SCIPsepaGetParentsepa, libscip), Ptr{SCIP_SEPA}, (Ptr{SCIP_SEPA},), sepa) + ccall( + (:SCIPsepaGetParentsepa, libscip), + Ptr{SCIP_SEPA}, + (Ptr{SCIP_SEPA},), + sepa, + ) end function SCIPsolGetOrigin(sol) @@ -24465,7 +78151,13 @@ function SCIPsolGetOrigObj(sol) end function SCIPsolOrigAddObjvalExact(sol, addval) - ccall((:SCIPsolOrigAddObjvalExact, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), sol, addval) + ccall( + (:SCIPsolOrigAddObjvalExact, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Ptr{SCIP_RATIONAL}), + sol, + addval, + ) end function SCIPsolGetTime(sol) @@ -24497,11 +78189,23 @@ function SCIPsolGetRelax(sol) end function SCIPsolSetHeur(sol, heur) - ccall((:SCIPsolSetHeur, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}), sol, heur) + ccall( + (:SCIPsolSetHeur, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Ptr{SCIP_HEUR}), + sol, + heur, + ) end function SCIPsolSetRelax(sol, relax) - ccall((:SCIPsolSetRelax, libscip), Cvoid, (Ptr{SCIP_SOL}, Ptr{SCIP_RELAX}), sol, relax) + ccall( + (:SCIPsolSetRelax, libscip), + Cvoid, + (Ptr{SCIP_SOL}, Ptr{SCIP_RELAX}), + sol, + relax, + ) end function SCIPsolSetLPRelaxation(sol) @@ -24521,39 +78225,85 @@ function SCIPsolGetIndex(sol) end function SCIPsolGetAbsBoundViolation(sol) - ccall((:SCIPsolGetAbsBoundViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) + ccall( + (:SCIPsolGetAbsBoundViolation, libscip), + Cdouble, + (Ptr{SCIP_SOL},), + sol, + ) end function SCIPsolGetRelBoundViolation(sol) - ccall((:SCIPsolGetRelBoundViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) + ccall( + (:SCIPsolGetRelBoundViolation, libscip), + Cdouble, + (Ptr{SCIP_SOL},), + sol, + ) end function SCIPsolGetAbsIntegralityViolation(sol) - ccall((:SCIPsolGetAbsIntegralityViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) + ccall( + (:SCIPsolGetAbsIntegralityViolation, libscip), + Cdouble, + (Ptr{SCIP_SOL},), + sol, + ) end function SCIPsolGetAbsLPRowViolation(sol) - ccall((:SCIPsolGetAbsLPRowViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) + ccall( + (:SCIPsolGetAbsLPRowViolation, libscip), + Cdouble, + (Ptr{SCIP_SOL},), + sol, + ) end function SCIPsolGetRelLPRowViolation(sol) - ccall((:SCIPsolGetRelLPRowViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) + ccall( + (:SCIPsolGetRelLPRowViolation, libscip), + Cdouble, + (Ptr{SCIP_SOL},), + sol, + ) end function SCIPsolGetAbsConsViolation(sol) - ccall((:SCIPsolGetAbsConsViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) + ccall( + (:SCIPsolGetAbsConsViolation, libscip), + Cdouble, + (Ptr{SCIP_SOL},), + sol, + ) end function SCIPsolGetRelConsViolation(sol) - ccall((:SCIPsolGetRelConsViolation, libscip), Cdouble, (Ptr{SCIP_SOL},), sol) + ccall( + (:SCIPsolGetRelConsViolation, libscip), + Cdouble, + (Ptr{SCIP_SOL},), + sol, + ) end function SCIPtableGetData(table) - ccall((:SCIPtableGetData, libscip), Ptr{SCIP_TABLEDATA}, (Ptr{SCIP_TABLE},), 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) + ccall( + (:SCIPtableSetData, libscip), + Cvoid, + (Ptr{SCIP_TABLE}, Ptr{SCIP_TABLEDATA}), + table, + tabledata, + ) end function SCIPtableGetName(table) @@ -24569,7 +78319,12 @@ function SCIPtableGetPosition(table) end function SCIPtableGetEarliestStage(table) - ccall((:SCIPtableGetEarliestStage, libscip), SCIP_STAGE, (Ptr{SCIP_TABLE},), table) + ccall( + (:SCIPtableGetEarliestStage, libscip), + SCIP_STAGE, + (Ptr{SCIP_TABLE},), + table, + ) end function SCIPtableIsActive(table) @@ -24581,35 +78336,167 @@ function SCIPtableIsInitialized(table) end 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) + 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{Libc.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) + ccall( + (:SCIPnodePrintAncestorBranchings, libscip), + SCIP_RETCODE, + (Ptr{SCIP_NODE}, Ptr{Libc.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), Cuint, (Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), node1, node2) + ccall( + (:SCIPnodesSharePath, libscip), + Cuint, + (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) + ccall( + (:SCIPnodesGetCommonAncestor, libscip), + Ptr{SCIP_NODE}, + (Ptr{SCIP_NODE}, Ptr{SCIP_NODE}), + node1, + node2, + ) end function SCIPnodeGetType(node) @@ -24629,7 +78516,12 @@ function SCIPnodeGetLowerbound(node) end function SCIPnodeGetLowerboundExact(node) - ccall((:SCIPnodeGetLowerboundExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_NODE},), node) + ccall( + (:SCIPnodeGetLowerboundExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_NODE},), + node, + ) end function SCIPnodeGetEstimate(node) @@ -24637,7 +78529,12 @@ function SCIPnodeGetEstimate(node) end function SCIPnodeGetReopttype(node) - ccall((:SCIPnodeGetReopttype, libscip), SCIP_REOPTTYPE, (Ptr{SCIP_NODE},), node) + ccall( + (:SCIPnodeGetReopttype, libscip), + SCIP_REOPTTYPE, + (Ptr{SCIP_NODE},), + node, + ) end function SCIPnodeGetReoptID(node) @@ -24645,27 +78542,65 @@ function SCIPnodeGetReoptID(node) end function SCIPnodeSetReopttype(node, reopttype) - ccall((:SCIPnodeSetReopttype, libscip), Cvoid, (Ptr{SCIP_NODE}, SCIP_REOPTTYPE), 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}, Cuint), node, id) + ccall( + (:SCIPnodeSetReoptID, libscip), + Cvoid, + (Ptr{SCIP_NODE}, Cuint), + 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) + 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) + ccall( + (:SCIPnodeGetDomchg, libscip), + Ptr{SCIP_DOMCHG}, + (Ptr{SCIP_NODE},), + node, + ) end function SCIPnodeGetParent(node) - ccall((:SCIPnodeGetParent, libscip), Ptr{SCIP_NODE}, (Ptr{SCIP_NODE},), 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) + ccall( + (:SCIPnodeGetAddedConss, libscip), + Cvoid, + (Ptr{SCIP_NODE}, Ptr{Ptr{SCIP_CONS}}, Ptr{Cint}, Cint), + node, + addedconss, + naddedconss, + addedconsssize, + ) end function SCIPnodeGetNAddedConss(node) @@ -24681,7 +78616,12 @@ function SCIPnodeIsPropagatedAgain(node) end function SCIPnodeGetConssetchg(node) - ccall((:SCIPnodeGetConssetchg, libscip), Ptr{SCIP_CONSSETCHG}, (Ptr{SCIP_NODE},), node) + ccall( + (:SCIPnodeGetConssetchg, libscip), + Ptr{SCIP_CONSSETCHG}, + (Ptr{SCIP_NODE},), + node, + ) end function SCIPvarGetNLocksDown(var) @@ -24693,11 +78633,23 @@ function SCIPvarGetNLocksUp(var) end function SCIPvarGetNLocksUpType(var, locktype) - ccall((:SCIPvarGetNLocksUpType, libscip), Cint, (Ptr{SCIP_VAR}, SCIP_LOCKTYPE), 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) + ccall( + (:SCIPvarGetNLocksDownType, libscip), + Cint, + (Ptr{SCIP_VAR}, SCIP_LOCKTYPE), + var, + locktype, + ) end function SCIPvarMayRoundDown(var) @@ -24709,15 +78661,33 @@ function SCIPvarMayRoundUp(var) end function SCIPvarCompareActiveAndNegated(var1, var2) - ccall((:SCIPvarCompareActiveAndNegated, libscip), Cint, (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), 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) + 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) + ccall( + (:SCIPvarCompare, libscip), + Cint, + (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), + var1, + var2, + ) end function SCIPvarComp(elem1, elem2) @@ -24725,23 +78695,54 @@ function SCIPvarComp(elem1, elem2) end function SCIPvarCompObj(elem1, elem2) - ccall((:SCIPvarCompObj, libscip), Cint, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPvarGetHashkey, libscip), + Ptr{Cvoid}, + (Ptr{Cvoid}, Ptr{Cvoid}), + userptr, + elem, + ) end function SCIPvarIsHashkeyEq(userptr, key1, key2) - ccall((:SCIPvarIsHashkeyEq, libscip), Cuint, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), userptr, key1, key2) + ccall( + (:SCIPvarIsHashkeyEq, libscip), + Cuint, + (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}), + userptr, + key1, + key2, + ) end function SCIPvarGetHashkeyVal(userptr, key) - ccall((:SCIPvarGetHashkeyVal, libscip), UInt64, (Ptr{Cvoid}, Ptr{Cvoid}), 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) + ccall( + (:SCIPvarsGetProbvar, libscip), + Cvoid, + (Ptr{Ptr{SCIP_VAR}}, Cint), + vars, + nvars, + ) end function SCIPvarGetProbvar(var) @@ -24749,31 +78750,79 @@ function SCIPvarGetProbvar(var) end function SCIPvarsGetProbvarBinary(vars, negatedarr, nvars) - ccall((:SCIPvarsGetProbvarBinary, libscip), SCIP_RETCODE, (Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cuint}}, Cint), vars, negatedarr, nvars) + ccall( + (:SCIPvarsGetProbvarBinary, libscip), + SCIP_RETCODE, + (Ptr{Ptr{Ptr{SCIP_VAR}}}, Ptr{Ptr{Cuint}}, Cint), + vars, + negatedarr, + nvars, + ) end function SCIPvarGetProbvarBinary(var, negated) - ccall((:SCIPvarGetProbvarBinary, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), var, negated) + ccall( + (:SCIPvarGetProbvarBinary, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_VAR}}, Ptr{Cuint}), + 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) + ccall( + (:SCIPvarGetProbvarBound, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{SCIP_BOUNDTYPE}), + var, + bound, + boundtype, + ) end function SCIPvarGetProbvarBoundExact(var, bound, boundtype) - ccall((:SCIPvarGetProbvarBoundExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_BOUNDTYPE}), var, bound, boundtype) + ccall( + (:SCIPvarGetProbvarBoundExact, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, 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) + 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) + ccall( + (:SCIPvarGetOrigvarSum, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_VAR}}, Ptr{Cdouble}, Ptr{Cdouble}), + var, + scalar, + constant, + ) end function SCIPvarGetOrigvarSumExact(var, scalar, constant) - ccall((:SCIPvarGetOrigvarSumExact, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), var, scalar, constant) + ccall( + (:SCIPvarGetOrigvarSumExact, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_VAR}}, Ptr{SCIP_RATIONAL}, Ptr{SCIP_RATIONAL}), + var, + scalar, + constant, + ) end function SCIPvarIsTransformedOrigvar(var) @@ -24781,63 +78830,163 @@ function SCIPvarIsTransformedOrigvar(var) end function SCIPvarGetNBranchings(var, dir) - ccall((:SCIPvarGetNBranchings, libscip), Clonglong, (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), 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) + 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) + 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) + 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) + 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) + 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) + 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) + ccall( + (:SCIPvarGetAvgBranchdepthCurrentRun, libscip), + Cdouble, + (Ptr{SCIP_VAR}, SCIP_BRANCHDIR), + var, + dir, + ) end function SCIPvarHasImplic(var, varfixing, implvar, impltype) - ccall((:SCIPvarHasImplic, libscip), Cuint, (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE), var, varfixing, implvar, impltype) + ccall( + (:SCIPvarHasImplic, libscip), + Cuint, + (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, SCIP_BOUNDTYPE), + var, + varfixing, + implvar, + impltype, + ) end function SCIPvarHasBinaryImplic(var, varfixing, implvar, implvarfixing) - ccall((:SCIPvarHasBinaryImplic, libscip), Cuint, (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint), var, varfixing, implvar, implvarfixing) + ccall( + (:SCIPvarHasBinaryImplic, libscip), + Cuint, + (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint), + var, + varfixing, + implvar, + implvarfixing, + ) end function SCIPvarGetImplicVarBounds(var, varfixing, implvar, lb, ub) - ccall((:SCIPvarGetImplicVarBounds, libscip), Cvoid, (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Ptr{Cdouble}, Ptr{Cdouble}), var, varfixing, implvar, lb, ub) + ccall( + (:SCIPvarGetImplicVarBounds, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Ptr{Cdouble}, Ptr{Cdouble}), + var, + varfixing, + implvar, + lb, + ub, + ) end function SCIPvarsHaveCommonClique(var1, value1, var2, value2, regardimplics) - ccall((:SCIPvarsHaveCommonClique, libscip), Cuint, (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint, Cuint), var1, value1, var2, value2, regardimplics) + ccall( + (:SCIPvarsHaveCommonClique, libscip), + Cuint, + (Ptr{SCIP_VAR}, Cuint, Ptr{SCIP_VAR}, Cuint, Cuint), + var1, + value1, + var2, + value2, + regardimplics, + ) end function SCIPvarGetAggregatedObj(var, aggrobj) - ccall((:SCIPvarGetAggregatedObj, libscip), SCIP_RETCODE, (Ptr{SCIP_VAR}, Ptr{Cdouble}), 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}, Cuint), var, initial) + ccall( + (:SCIPvarSetInitial, libscip), + SCIP_RETCODE, + (Ptr{SCIP_VAR}, Cuint), + var, + initial, + ) end function SCIPvarSetRemovable(var, removable) - ccall((:SCIPvarSetRemovable, libscip), SCIP_RETCODE, (Ptr{SCIP_VAR}, Cuint), var, removable) + ccall( + (:SCIPvarSetRemovable, libscip), + SCIP_RETCODE, + (Ptr{SCIP_VAR}, Cuint), + var, + removable, + ) end function SCIPvarGetName(var) @@ -24853,23 +79002,53 @@ function SCIPvarGetData(var) end function SCIPvarSetData(var, vardata) - ccall((:SCIPvarSetData, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{SCIP_VARDATA}), 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) + 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) + 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) + 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) + ccall( + (:SCIPvarSetCopyData, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Ptr{Cvoid}), + var, + varcopy, + ) end function SCIPvarGetStatus(var) @@ -24877,7 +79056,12 @@ function SCIPvarGetStatus(var) end function SCIPvarGetStatusExact(var) - ccall((:SCIPvarGetStatusExact, libscip), SCIP_VARSTATUS, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetStatusExact, libscip), + SCIP_VARSTATUS, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarIsExact(var) @@ -24901,7 +79085,12 @@ function SCIPvarGetType(var) end function SCIPvarGetImplType(var) - ccall((:SCIPvarGetImplType, libscip), SCIP_IMPLINTTYPE, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetImplType, libscip), + SCIP_IMPLINTTYPE, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarIsBinary(var) @@ -24945,7 +79134,12 @@ function SCIPvarIsDeletable(var) end function SCIPvarMarkDeleteGlobalStructures(var) - ccall((:SCIPvarMarkDeleteGlobalStructures, libscip), Cvoid, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarMarkDeleteGlobalStructures, libscip), + Cvoid, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarIsActive(var) @@ -24965,31 +79159,69 @@ function SCIPvarGetCertificateIndex(var) end function SCIPvarSetCertificateIndex(var, certidx) - ccall((:SCIPvarSetCertificateIndex, libscip), Cvoid, (Ptr{SCIP_VAR}, Cint), var, certidx) + ccall( + (:SCIPvarSetCertificateIndex, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Cint), + var, + certidx, + ) end function SCIPvarSetUbCertificateIndexGlobal(var, certidx) - ccall((:SCIPvarSetUbCertificateIndexGlobal, libscip), Cvoid, (Ptr{SCIP_VAR}, Clonglong), var, certidx) + ccall( + (:SCIPvarSetUbCertificateIndexGlobal, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Clonglong), + var, + certidx, + ) end function SCIPvarSetLbCertificateIndexGlobal(var, certidx) - ccall((:SCIPvarSetLbCertificateIndexGlobal, libscip), Cvoid, (Ptr{SCIP_VAR}, Clonglong), var, certidx) + ccall( + (:SCIPvarSetLbCertificateIndexGlobal, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Clonglong), + var, + certidx, + ) end function SCIPvarGetLbCertificateIndexLocal(var) - ccall((:SCIPvarGetLbCertificateIndexLocal, libscip), Clonglong, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetLbCertificateIndexLocal, libscip), + Clonglong, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetUbCertificateIndexLocal(var) - ccall((:SCIPvarGetUbCertificateIndexLocal, libscip), Clonglong, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetUbCertificateIndexLocal, libscip), + Clonglong, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetLbCertificateIndexGlobal(var) - ccall((:SCIPvarGetLbCertificateIndexGlobal, libscip), Clonglong, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetLbCertificateIndexGlobal, libscip), + Clonglong, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetUbCertificateIndexGlobal(var) - ccall((:SCIPvarGetUbCertificateIndexGlobal, libscip), Clonglong, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetUbCertificateIndexGlobal, libscip), + Clonglong, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetTransVar(var) @@ -25001,7 +79233,12 @@ function SCIPvarGetCol(var) end function SCIPvarGetColExact(var) - ccall((:SCIPvarGetColExact, libscip), Ptr{SCIP_COLEXACT}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetColExact, libscip), + Ptr{SCIP_COLEXACT}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarIsInLP(var) @@ -25025,7 +79262,12 @@ function SCIPvarGetAggrScalar(var) end function SCIPvarGetAggrScalarExact(var) - ccall((:SCIPvarGetAggrScalarExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetAggrScalarExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetAggrConstant(var) @@ -25033,7 +79275,12 @@ function SCIPvarGetAggrConstant(var) end function SCIPvarGetAggrConstantExact(var) - ccall((:SCIPvarGetAggrConstantExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetAggrConstantExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetMultaggrNVars(var) @@ -25041,35 +79288,75 @@ function SCIPvarGetMultaggrNVars(var) end function SCIPvarGetMultaggrVars(var) - ccall((:SCIPvarGetMultaggrVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), 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) + ccall( + (:SCIPvarGetMultaggrScalars, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetMultaggrScalarsExact(var) - ccall((:SCIPvarGetMultaggrScalarsExact, libscip), Ptr{Ptr{SCIP_RATIONAL}}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetMultaggrScalarsExact, libscip), + Ptr{Ptr{SCIP_RATIONAL}}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetMultaggrConstant(var) - ccall((:SCIPvarGetMultaggrConstant, libscip), Cdouble, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetMultaggrConstant, libscip), + Cdouble, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetMultaggrConstantExact(var) - ccall((:SCIPvarGetMultaggrConstantExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetMultaggrConstantExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetNegatedVar(var) - ccall((:SCIPvarGetNegatedVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_VAR},), 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) + ccall( + (:SCIPvarGetNegationVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetNegationConstant(var) - ccall((:SCIPvarGetNegationConstant, libscip), Cdouble, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetNegationConstant, libscip), + Cdouble, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetObj(var) @@ -25077,11 +79364,21 @@ function SCIPvarGetObj(var) end function SCIPvarGetObjExact(var) - ccall((:SCIPvarGetObjExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetObjExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetObjInterval(var) - ccall((:SCIPvarGetObjInterval, libscip), SCIP_INTERVAL, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetObjInterval, libscip), + SCIP_INTERVAL, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetUnchangedObj(var) @@ -25093,7 +79390,12 @@ function SCIPvarGetLbOriginal(var) end function SCIPvarGetLbOriginalExact(var) - ccall((:SCIPvarGetLbOriginalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetLbOriginalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetUbOriginal(var) @@ -25101,11 +79403,21 @@ function SCIPvarGetUbOriginal(var) end function SCIPvarGetUbOriginalExact(var) - ccall((:SCIPvarGetUbOriginalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetUbOriginalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetHolelistOriginal(var) - ccall((:SCIPvarGetHolelistOriginal, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetHolelistOriginal, libscip), + Ptr{SCIP_HOLELIST}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetLbGlobal(var) @@ -25113,7 +79425,12 @@ function SCIPvarGetLbGlobal(var) end function SCIPvarGetLbGlobalExact(var) - ccall((:SCIPvarGetLbGlobalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetLbGlobalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetUbGlobal(var) @@ -25121,11 +79438,21 @@ function SCIPvarGetUbGlobal(var) end function SCIPvarGetUbGlobalExact(var) - ccall((:SCIPvarGetUbGlobalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetUbGlobalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetHolelistGlobal(var) - ccall((:SCIPvarGetHolelistGlobal, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetHolelistGlobal, libscip), + Ptr{SCIP_HOLELIST}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetBestBoundGlobal(var) @@ -25133,15 +79460,30 @@ function SCIPvarGetBestBoundGlobal(var) end function SCIPvarGetBestBoundGlobalExact(var) - ccall((:SCIPvarGetBestBoundGlobalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetBestBoundGlobalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetWorstBoundGlobal(var) - ccall((:SCIPvarGetWorstBoundGlobal, libscip), Cdouble, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetWorstBoundGlobal, libscip), + Cdouble, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetWorstBoundGlobalExact(var) - ccall((:SCIPvarGetWorstBoundGlobalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetWorstBoundGlobalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetLbLocal(var) @@ -25149,7 +79491,12 @@ function SCIPvarGetLbLocal(var) end function SCIPvarGetLbLocalExact(var) - ccall((:SCIPvarGetLbLocalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetLbLocalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetUbLocal(var) @@ -25157,11 +79504,21 @@ function SCIPvarGetUbLocal(var) end function SCIPvarGetUbLocalExact(var) - ccall((:SCIPvarGetUbLocalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetUbLocalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetHolelistLocal(var) - ccall((:SCIPvarGetHolelistLocal, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetHolelistLocal, libscip), + Ptr{SCIP_HOLELIST}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetBestBoundLocal(var) @@ -25169,7 +79526,12 @@ function SCIPvarGetBestBoundLocal(var) end function SCIPvarGetBestBoundLocalExact(var) - ccall((:SCIPvarGetBestBoundLocalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetBestBoundLocalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetWorstBoundLocal(var) @@ -25177,23 +79539,48 @@ function SCIPvarGetWorstBoundLocal(var) end function SCIPvarGetWorstBoundLocalExact(var) - ccall((:SCIPvarGetWorstBoundLocalExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetWorstBoundLocalExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetBestBoundType(var) - ccall((:SCIPvarGetBestBoundType, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetBestBoundType, libscip), + SCIP_BOUNDTYPE, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetBestBoundTypeExact(var) - ccall((:SCIPvarGetBestBoundTypeExact, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetBestBoundTypeExact, libscip), + SCIP_BOUNDTYPE, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetWorstBoundType(var) - ccall((:SCIPvarGetWorstBoundType, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetWorstBoundType, libscip), + SCIP_BOUNDTYPE, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetWorstBoundTypeExact(var) - ccall((:SCIPvarGetWorstBoundTypeExact, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetWorstBoundTypeExact, libscip), + SCIP_BOUNDTYPE, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetLbLazy(var) @@ -25213,7 +79600,12 @@ function SCIPvarGetBranchPriority(var) end function SCIPvarGetBranchDirection(var) - ccall((:SCIPvarGetBranchDirection, libscip), SCIP_BRANCHDIR, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetBranchDirection, libscip), + SCIP_BRANCHDIR, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetNVlbs(var) @@ -25221,7 +79613,12 @@ function SCIPvarGetNVlbs(var) end function SCIPvarGetVlbVars(var) - ccall((:SCIPvarGetVlbVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetVlbVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetVlbCoefs(var) @@ -25229,7 +79626,12 @@ function SCIPvarGetVlbCoefs(var) end function SCIPvarGetVlbConstants(var) - ccall((:SCIPvarGetVlbConstants, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetVlbConstants, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetNVubs(var) @@ -25237,7 +79639,12 @@ function SCIPvarGetNVubs(var) end function SCIPvarGetVubVars(var) - ccall((:SCIPvarGetVubVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetVubVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetVubCoefs(var) @@ -25245,35 +79652,82 @@ function SCIPvarGetVubCoefs(var) end function SCIPvarGetVubConstants(var) - ccall((:SCIPvarGetVubConstants, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetVubConstants, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetNImpls(var, varfixing) - ccall((:SCIPvarGetNImpls, libscip), Cint, (Ptr{SCIP_VAR}, Cuint), var, varfixing) + ccall( + (:SCIPvarGetNImpls, libscip), + Cint, + (Ptr{SCIP_VAR}, Cuint), + var, + varfixing, + ) end function SCIPvarGetImplVars(var, varfixing) - ccall((:SCIPvarGetImplVars, libscip), Ptr{Ptr{SCIP_VAR}}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) + ccall( + (:SCIPvarGetImplVars, libscip), + Ptr{Ptr{SCIP_VAR}}, + (Ptr{SCIP_VAR}, Cuint), + var, + varfixing, + ) end function SCIPvarGetImplTypes(var, varfixing) - ccall((:SCIPvarGetImplTypes, libscip), Ptr{SCIP_BOUNDTYPE}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) + ccall( + (:SCIPvarGetImplTypes, libscip), + Ptr{SCIP_BOUNDTYPE}, + (Ptr{SCIP_VAR}, Cuint), + var, + varfixing, + ) end function SCIPvarGetImplBounds(var, varfixing) - ccall((:SCIPvarGetImplBounds, libscip), Ptr{Cdouble}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) + ccall( + (:SCIPvarGetImplBounds, libscip), + Ptr{Cdouble}, + (Ptr{SCIP_VAR}, Cuint), + var, + varfixing, + ) end function SCIPvarGetImplIds(var, varfixing) - ccall((:SCIPvarGetImplIds, libscip), Ptr{Cint}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) + ccall( + (:SCIPvarGetImplIds, libscip), + Ptr{Cint}, + (Ptr{SCIP_VAR}, Cuint), + var, + varfixing, + ) end function SCIPvarGetNCliques(var, varfixing) - ccall((:SCIPvarGetNCliques, libscip), Cint, (Ptr{SCIP_VAR}, Cuint), var, varfixing) + ccall( + (:SCIPvarGetNCliques, libscip), + Cint, + (Ptr{SCIP_VAR}, Cuint), + var, + varfixing, + ) end function SCIPvarGetCliques(var, varfixing) - ccall((:SCIPvarGetCliques, libscip), Ptr{Ptr{SCIP_CLIQUE}}, (Ptr{SCIP_VAR}, Cuint), var, varfixing) + ccall( + (:SCIPvarGetCliques, libscip), + Ptr{Ptr{SCIP_CLIQUE}}, + (Ptr{SCIP_VAR}, Cuint), + var, + varfixing, + ) end function SCIPvarGetLPSol(var) @@ -25281,7 +79735,13 @@ function SCIPvarGetLPSol(var) end function SCIPvarGetLPSolExact(var, res) - ccall((:SCIPvarGetLPSolExact, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), var, res) + ccall( + (:SCIPvarGetLPSolExact, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + var, + res, + ) end function SCIPvarGetNLPSol(var) @@ -25289,7 +79749,13 @@ function SCIPvarGetNLPSol(var) end function SCIPvarGetBdchgInfoLb(var, pos) - ccall((:SCIPvarGetBdchgInfoLb, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Cint), var, pos) + ccall( + (:SCIPvarGetBdchgInfoLb, libscip), + Ptr{SCIP_BDCHGINFO}, + (Ptr{SCIP_VAR}, Cint), + var, + pos, + ) end function SCIPvarGetNBdchgInfosLb(var) @@ -25297,7 +79763,13 @@ function SCIPvarGetNBdchgInfosLb(var) end function SCIPvarGetBdchgInfoUb(var, pos) - ccall((:SCIPvarGetBdchgInfoUb, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Cint), var, pos) + ccall( + (:SCIPvarGetBdchgInfoUb, libscip), + Ptr{SCIP_BDCHGINFO}, + (Ptr{SCIP_VAR}, Cint), + var, + pos, + ) end function SCIPvarGetNBdchgInfosUb(var) @@ -25305,7 +79777,12 @@ function SCIPvarGetNBdchgInfosUb(var) end function SCIPvarGetValuehistory(var) - ccall((:SCIPvarGetValuehistory, libscip), Ptr{SCIP_VALUEHISTORY}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetValuehistory, libscip), + Ptr{SCIP_VALUEHISTORY}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarIsRelaxationOnly(var) @@ -25321,7 +79798,13 @@ function SCIPvarGetLPSol_rec(var) end function SCIPvarGetLPSolExact_rec(var, res) - ccall((:SCIPvarGetLPSolExact_rec, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), var, res) + ccall( + (:SCIPvarGetLPSolExact_rec, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}), + var, + res, + ) end function SCIPvarGetNLPSol_rec(var) @@ -25333,15 +79816,33 @@ function SCIPvarGetPseudoSol(var) end function SCIPvarGetPseudoSolExact(var) - ccall((:SCIPvarGetPseudoSolExact, libscip), Ptr{SCIP_RATIONAL}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetPseudoSolExact, libscip), + Ptr{SCIP_RATIONAL}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetSol(var, getlpval) - ccall((:SCIPvarGetSol, libscip), Cdouble, (Ptr{SCIP_VAR}, Cuint), var, getlpval) + ccall( + (:SCIPvarGetSol, libscip), + Cdouble, + (Ptr{SCIP_VAR}, Cuint), + var, + getlpval, + ) end function SCIPvarGetSolExact(var, res, getlpval) - ccall((:SCIPvarGetSolExact, libscip), Cvoid, (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Cuint), var, res, getlpval) + ccall( + (:SCIPvarGetSolExact, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Ptr{SCIP_RATIONAL}, Cuint), + var, + res, + getlpval, + ) end function SCIPvarGetRootSol(var) @@ -25357,11 +79858,24 @@ function SCIPvarGetBestRootRedcost(var) end function SCIPvarGetBestRootLPObjval(var) - ccall((:SCIPvarGetBestRootLPObjval, libscip), Cdouble, (Ptr{SCIP_VAR},), 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) + ccall( + (:SCIPvarSetBestRootSol, libscip), + Cvoid, + (Ptr{SCIP_VAR}, Cdouble, Cdouble, Cdouble), + var, + rootsol, + rootredcost, + rootlpobjval, + ) end function SCIPvarGetAvgSol(var) @@ -25369,19 +79883,46 @@ function SCIPvarGetAvgSol(var) end function SCIPvarGetLbchgInfo(var, bdchgidx, after) - ccall((:SCIPvarGetLbchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), var, bdchgidx, after) + ccall( + (:SCIPvarGetLbchgInfo, libscip), + Ptr{SCIP_BDCHGINFO}, + (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), + var, + bdchgidx, + after, + ) end function SCIPvarGetUbchgInfo(var, bdchgidx, after) - ccall((:SCIPvarGetUbchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), var, bdchgidx, after) + ccall( + (:SCIPvarGetUbchgInfo, libscip), + Ptr{SCIP_BDCHGINFO}, + (Ptr{SCIP_VAR}, Ptr{SCIP_BDCHGIDX}, Cuint), + var, + bdchgidx, + after, + ) end function SCIPvarGetBdchgInfo(var, boundtype, bdchgidx, after) - ccall((:SCIPvarGetBdchgInfo, libscip), Ptr{SCIP_BDCHGINFO}, (Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cuint), var, boundtype, bdchgidx, after) + ccall( + (:SCIPvarGetBdchgInfo, libscip), + Ptr{SCIP_BDCHGINFO}, + (Ptr{SCIP_VAR}, SCIP_BOUNDTYPE, Ptr{SCIP_BDCHGIDX}, Cuint), + var, + boundtype, + bdchgidx, + after, + ) end function SCIPvarGetLastBdchgIndex(var) - ccall((:SCIPvarGetLastBdchgIndex, libscip), Ptr{SCIP_BDCHGIDX}, (Ptr{SCIP_VAR},), var) + ccall( + (:SCIPvarGetLastBdchgIndex, libscip), + Ptr{SCIP_BDCHGIDX}, + (Ptr{SCIP_VAR},), + var, + ) end function SCIPvarGetLastBdchgDepth(var) @@ -25389,139 +79930,344 @@ function SCIPvarGetLastBdchgDepth(var) end function SCIPvarWasFixedEarlier(var1, var2) - ccall((:SCIPvarWasFixedEarlier, libscip), Cuint, (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), var1, var2) -end - -function SCIPvarsCountTypes(vars, nvars, nbinvars, nintvars, nbinimplvars, nintimplvars, ncontimplvars, ncontvars) - ccall((:SCIPvarsCountTypes, libscip), Cvoid, (Ptr{Ptr{SCIP_VAR}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), vars, nvars, nbinvars, nintvars, nbinimplvars, nintimplvars, ncontimplvars, ncontvars) + ccall( + (:SCIPvarWasFixedEarlier, libscip), + Cuint, + (Ptr{SCIP_VAR}, Ptr{SCIP_VAR}), + var1, + var2, + ) +end + +function SCIPvarsCountTypes( + vars, + nvars, + nbinvars, + nintvars, + nbinimplvars, + nintimplvars, + ncontimplvars, + ncontvars, +) + ccall( + (:SCIPvarsCountTypes, libscip), + Cvoid, + ( + Ptr{Ptr{SCIP_VAR}}, + Cint, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + ), + vars, + nvars, + nbinvars, + nintvars, + nbinimplvars, + nintimplvars, + ncontimplvars, + ncontvars, + ) end function SCIPbdchgidxIsEarlier(bdchgidx1, bdchgidx2) - ccall((:SCIPbdchgidxIsEarlier, libscip), Cuint, (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), bdchgidx1, bdchgidx2) + ccall( + (:SCIPbdchgidxIsEarlier, libscip), + Cuint, + (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), + bdchgidx1, + bdchgidx2, + ) end function SCIPbdchgidxIsEarlierNonNull(bdchgidx1, bdchgidx2) - ccall((:SCIPbdchgidxIsEarlierNonNull, libscip), Cuint, (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), bdchgidx1, bdchgidx2) + ccall( + (:SCIPbdchgidxIsEarlierNonNull, libscip), + Cuint, + (Ptr{SCIP_BDCHGIDX}, Ptr{SCIP_BDCHGIDX}), + bdchgidx1, + bdchgidx2, + ) end function SCIPbdchginfoGetOldbound(bdchginfo) - ccall((:SCIPbdchginfoGetOldbound, libscip), Cdouble, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetOldbound, libscip), + Cdouble, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetNewbound(bdchginfo) - ccall((:SCIPbdchginfoGetNewbound, libscip), Cdouble, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetNewbound, libscip), + Cdouble, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetVar(bdchginfo) - ccall((:SCIPbdchginfoGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetChgtype(bdchginfo) - ccall((:SCIPbdchginfoGetChgtype, libscip), SCIP_BOUNDCHGTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetChgtype, libscip), + SCIP_BOUNDCHGTYPE, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetBoundtype(bdchginfo) - ccall((:SCIPbdchginfoGetBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetBoundtype, libscip), + SCIP_BOUNDTYPE, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetDepth(bdchginfo) - ccall((:SCIPbdchginfoGetDepth, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetDepth, libscip), + Cint, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetPos(bdchginfo) - ccall((:SCIPbdchginfoGetPos, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetPos, libscip), + Cint, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetIdx(bdchginfo) - ccall((:SCIPbdchginfoGetIdx, libscip), Ptr{SCIP_BDCHGIDX}, (Ptr{SCIP_BDCHGINFO},), 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) + ccall( + (:SCIPbdchginfoGetInferVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetInferCons(bdchginfo) - ccall((:SCIPbdchginfoGetInferCons, libscip), Ptr{SCIP_CONS}, (Ptr{SCIP_BDCHGINFO},), 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) + ccall( + (:SCIPbdchginfoGetInferProp, libscip), + Ptr{SCIP_PROP}, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetInferInfo(bdchginfo) - ccall((:SCIPbdchginfoGetInferInfo, libscip), Cint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetInferInfo, libscip), + Cint, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoGetInferBoundtype(bdchginfo) - ccall((:SCIPbdchginfoGetInferBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoGetInferBoundtype, libscip), + SCIP_BOUNDTYPE, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoIsRedundant(bdchginfo) - ccall((:SCIPbdchginfoIsRedundant, libscip), Cuint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoIsRedundant, libscip), + Cuint, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoHasInferenceReason(bdchginfo) - ccall((:SCIPbdchginfoHasInferenceReason, libscip), Cuint, (Ptr{SCIP_BDCHGINFO},), bdchginfo) + ccall( + (:SCIPbdchginfoHasInferenceReason, libscip), + Cuint, + (Ptr{SCIP_BDCHGINFO},), + bdchginfo, + ) end function SCIPbdchginfoIsTighter(bdchginfo1, bdchginfo2) - ccall((:SCIPbdchginfoIsTighter, libscip), Cuint, (Ptr{SCIP_BDCHGINFO}, Ptr{SCIP_BDCHGINFO}), bdchginfo1, bdchginfo2) + ccall( + (:SCIPbdchginfoIsTighter, libscip), + Cuint, + (Ptr{SCIP_BDCHGINFO}, Ptr{SCIP_BDCHGINFO}), + bdchginfo1, + bdchginfo2, + ) end function SCIPboundchgGetNewbound(boundchg) - ccall((:SCIPboundchgGetNewbound, libscip), Cdouble, (Ptr{SCIP_BOUNDCHG},), boundchg) + ccall( + (:SCIPboundchgGetNewbound, libscip), + Cdouble, + (Ptr{SCIP_BOUNDCHG},), + boundchg, + ) end function SCIPboundchgGetLPSolVal(boundchg) - ccall((:SCIPboundchgGetLPSolVal, libscip), Cdouble, (Ptr{SCIP_BOUNDCHG},), boundchg) + ccall( + (:SCIPboundchgGetLPSolVal, libscip), + Cdouble, + (Ptr{SCIP_BOUNDCHG},), + boundchg, + ) end function SCIPboundchgGetVar(boundchg) - ccall((:SCIPboundchgGetVar, libscip), Ptr{SCIP_VAR}, (Ptr{SCIP_BOUNDCHG},), boundchg) + ccall( + (:SCIPboundchgGetVar, libscip), + Ptr{SCIP_VAR}, + (Ptr{SCIP_BOUNDCHG},), + boundchg, + ) end function SCIPboundchgGetBoundchgtype(boundchg) - ccall((:SCIPboundchgGetBoundchgtype, libscip), SCIP_BOUNDCHGTYPE, (Ptr{SCIP_BOUNDCHG},), boundchg) + ccall( + (:SCIPboundchgGetBoundchgtype, libscip), + SCIP_BOUNDCHGTYPE, + (Ptr{SCIP_BOUNDCHG},), + boundchg, + ) end function SCIPboundchgGetBoundtype(boundchg) - ccall((:SCIPboundchgGetBoundtype, libscip), SCIP_BOUNDTYPE, (Ptr{SCIP_BOUNDCHG},), boundchg) + ccall( + (:SCIPboundchgGetBoundtype, libscip), + SCIP_BOUNDTYPE, + (Ptr{SCIP_BOUNDCHG},), + boundchg, + ) end function SCIPboundchgIsRedundant(boundchg) - ccall((:SCIPboundchgIsRedundant, libscip), Cuint, (Ptr{SCIP_BOUNDCHG},), boundchg) + ccall( + (:SCIPboundchgIsRedundant, libscip), + Cuint, + (Ptr{SCIP_BOUNDCHG},), + boundchg, + ) end function SCIPdomchgGetNBoundchgs(domchg) - ccall((:SCIPdomchgGetNBoundchgs, libscip), Cint, (Ptr{SCIP_DOMCHG},), 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) + ccall( + (:SCIPdomchgGetBoundchg, libscip), + Ptr{SCIP_BOUNDCHG}, + (Ptr{SCIP_DOMCHG}, Cint), + domchg, + pos, + ) end function SCIPholelistGetLeft(holelist) - ccall((:SCIPholelistGetLeft, libscip), Cdouble, (Ptr{SCIP_HOLELIST},), holelist) + ccall( + (:SCIPholelistGetLeft, libscip), + Cdouble, + (Ptr{SCIP_HOLELIST},), + holelist, + ) end function SCIPholelistGetRight(holelist) - ccall((:SCIPholelistGetRight, libscip), Cdouble, (Ptr{SCIP_HOLELIST},), holelist) + ccall( + (:SCIPholelistGetRight, libscip), + Cdouble, + (Ptr{SCIP_HOLELIST},), + holelist, + ) end function SCIPholelistGetNext(holelist) - ccall((:SCIPholelistGetNext, libscip), Ptr{SCIP_HOLELIST}, (Ptr{SCIP_HOLELIST},), holelist) + ccall( + (:SCIPholelistGetNext, libscip), + Ptr{SCIP_HOLELIST}, + (Ptr{SCIP_HOLELIST},), + holelist, + ) end function BMSclearMemory_call(ptr, size) - ccall((:BMSclearMemory_call, libscip), Cvoid, (Ptr{Cvoid}, Csize_t), ptr, size) + ccall( + (:BMSclearMemory_call, libscip), + Cvoid, + (Ptr{Cvoid}, Csize_t), + ptr, + size, + ) end function BMScopyMemory_call(ptr, source, size) - ccall((:BMScopyMemory_call, libscip), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), ptr, source, size) + ccall( + (:BMScopyMemory_call, libscip), + Cvoid, + (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), + ptr, + source, + size, + ) end function BMSmoveMemory_call(ptr, source, size) - ccall((:BMSmoveMemory_call, libscip), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), ptr, source, size) + ccall( + (:BMSmoveMemory_call, libscip), + Cvoid, + (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), + ptr, + source, + size, + ) end function BMSgetPointerSize_call(ptr) @@ -25544,100 +80290,269 @@ const BMS_ChkMem = Cvoid const BMS_CHKMEM = BMS_ChkMem -function BMScreateChunkMemory_call(size, initchunksize, garbagefactor, filename, line) - ccall((:BMScreateChunkMemory_call, libscip), Ptr{BMS_CHKMEM}, (Csize_t, Cint, Cint, Ptr{Cchar}, Cint), size, initchunksize, garbagefactor, filename, line) +function BMScreateChunkMemory_call( + size, + initchunksize, + garbagefactor, + filename, + line, +) + ccall( + (:BMScreateChunkMemory_call, libscip), + Ptr{BMS_CHKMEM}, + (Csize_t, Cint, Cint, Ptr{Cchar}, Cint), + size, + initchunksize, + garbagefactor, + filename, + line, + ) end function BMSclearChunkMemory_call(chkmem, filename, line) - ccall((:BMSclearChunkMemory_call, libscip), Cvoid, (Ptr{BMS_CHKMEM}, Ptr{Cchar}, Cint), chkmem, filename, line) + ccall( + (:BMSclearChunkMemory_call, libscip), + Cvoid, + (Ptr{BMS_CHKMEM}, Ptr{Cchar}, Cint), + chkmem, + filename, + line, + ) end function BMSdestroyChunkMemory_call(chkmem, filename, line) - ccall((:BMSdestroyChunkMemory_call, libscip), Cvoid, (Ptr{Ptr{BMS_CHKMEM}}, Ptr{Cchar}, Cint), chkmem, filename, line) + ccall( + (:BMSdestroyChunkMemory_call, libscip), + Cvoid, + (Ptr{Ptr{BMS_CHKMEM}}, Ptr{Cchar}, Cint), + chkmem, + filename, + line, + ) end function BMSallocChunkMemory_call(chkmem, size, filename, line) - ccall((:BMSallocChunkMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_CHKMEM}, Csize_t, Ptr{Cchar}, Cint), chkmem, size, filename, line) + ccall( + (:BMSallocChunkMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_CHKMEM}, Csize_t, Ptr{Cchar}, Cint), + chkmem, + size, + filename, + line, + ) end function BMSduplicateChunkMemory_call(chkmem, source, size, filename, line) - ccall((:BMSduplicateChunkMemory_call, libscip), Ptr{Cvoid}, (Ptr{BMS_CHKMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), chkmem, source, size, filename, line) + ccall( + (:BMSduplicateChunkMemory_call, libscip), + Ptr{Cvoid}, + (Ptr{BMS_CHKMEM}, Ptr{Cvoid}, Csize_t, Ptr{Cchar}, Cint), + chkmem, + source, + size, + filename, + line, + ) end function BMSfreeChunkMemory_call(chkmem, ptr, size, filename, line) - ccall((:BMSfreeChunkMemory_call, libscip), Cvoid, (Ptr{BMS_CHKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), chkmem, ptr, size, filename, line) + ccall( + (:BMSfreeChunkMemory_call, libscip), + Cvoid, + (Ptr{BMS_CHKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), + chkmem, + ptr, + size, + filename, + line, + ) end function BMSfreeChunkMemoryNull_call(chkmem, ptr, size, filename, line) - ccall((:BMSfreeChunkMemoryNull_call, libscip), Cvoid, (Ptr{BMS_CHKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), chkmem, ptr, size, filename, line) + ccall( + (:BMSfreeChunkMemoryNull_call, libscip), + Cvoid, + (Ptr{BMS_CHKMEM}, Ptr{Ptr{Cvoid}}, Csize_t, Ptr{Cchar}, Cint), + chkmem, + ptr, + size, + filename, + line, + ) end function BMSgarbagecollectChunkMemory_call(chkmem) - ccall((:BMSgarbagecollectChunkMemory_call, libscip), Cvoid, (Ptr{BMS_CHKMEM},), chkmem) + ccall( + (:BMSgarbagecollectChunkMemory_call, libscip), + Cvoid, + (Ptr{BMS_CHKMEM},), + chkmem, + ) end function BMSgetChunkMemoryUsed_call(chkmem) - ccall((:BMSgetChunkMemoryUsed_call, libscip), Clonglong, (Ptr{BMS_CHKMEM},), chkmem) + ccall( + (:BMSgetChunkMemoryUsed_call, libscip), + Clonglong, + (Ptr{BMS_CHKMEM},), + chkmem, + ) end function BMScreateBlockMemory_call(initchunksize, garbagefactor, filename, line) - ccall((:BMScreateBlockMemory_call, libscip), Ptr{BMS_BLKMEM}, (Cint, Cint, Ptr{Cchar}, Cint), initchunksize, garbagefactor, filename, line) + ccall( + (:BMScreateBlockMemory_call, libscip), + Ptr{BMS_BLKMEM}, + (Cint, Cint, Ptr{Cchar}, Cint), + initchunksize, + garbagefactor, + filename, + line, + ) end function BMSclearBlockMemory_call(blkmem, filename, line) - ccall((:BMSclearBlockMemory_call, libscip), Cvoid, (Ptr{BMS_BLKMEM}, Ptr{Cchar}, Cint), blkmem, filename, line) + ccall( + (:BMSclearBlockMemory_call, libscip), + Cvoid, + (Ptr{BMS_BLKMEM}, Ptr{Cchar}, Cint), + blkmem, + filename, + line, + ) end function BMSdestroyBlockMemory_call(blkmem, filename, line) - ccall((:BMSdestroyBlockMemory_call, libscip), Cvoid, (Ptr{Ptr{BMS_BLKMEM}}, Ptr{Cchar}, Cint), blkmem, filename, line) + ccall( + (:BMSdestroyBlockMemory_call, libscip), + Cvoid, + (Ptr{Ptr{BMS_BLKMEM}}, Ptr{Cchar}, Cint), + blkmem, + filename, + line, + ) end function BMSgarbagecollectBlockMemory_call(blkmem) - ccall((:BMSgarbagecollectBlockMemory_call, libscip), Cvoid, (Ptr{BMS_BLKMEM},), blkmem) + ccall( + (:BMSgarbagecollectBlockMemory_call, libscip), + Cvoid, + (Ptr{BMS_BLKMEM},), + blkmem, + ) end function BMSgetBlockMemoryAllocated_call(blkmem) - ccall((:BMSgetBlockMemoryAllocated_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) + ccall( + (:BMSgetBlockMemoryAllocated_call, libscip), + Clonglong, + (Ptr{BMS_BLKMEM},), + blkmem, + ) end function BMSgetBlockMemoryUsed_call(blkmem) - ccall((:BMSgetBlockMemoryUsed_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) + ccall( + (:BMSgetBlockMemoryUsed_call, libscip), + Clonglong, + (Ptr{BMS_BLKMEM},), + blkmem, + ) end function BMSgetBlockMemoryUnused_call(blkmem) - ccall((:BMSgetBlockMemoryUnused_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) + ccall( + (:BMSgetBlockMemoryUnused_call, libscip), + Clonglong, + (Ptr{BMS_BLKMEM},), + blkmem, + ) end function BMSgetBlockMemoryUsedMax_call(blkmem) - ccall((:BMSgetBlockMemoryUsedMax_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) + ccall( + (:BMSgetBlockMemoryUsedMax_call, libscip), + Clonglong, + (Ptr{BMS_BLKMEM},), + blkmem, + ) end function BMSgetBlockMemoryUnusedMax_call(blkmem) - ccall((:BMSgetBlockMemoryUnusedMax_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) + ccall( + (:BMSgetBlockMemoryUnusedMax_call, libscip), + Clonglong, + (Ptr{BMS_BLKMEM},), + blkmem, + ) end function BMSgetBlockMemoryAllocatedMax_call(blkmem) - ccall((:BMSgetBlockMemoryAllocatedMax_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) + ccall( + (:BMSgetBlockMemoryAllocatedMax_call, libscip), + Clonglong, + (Ptr{BMS_BLKMEM},), + blkmem, + ) end function BMSgetBlockPointerSize_call(blkmem, ptr) - ccall((:BMSgetBlockPointerSize_call, libscip), Csize_t, (Ptr{BMS_BLKMEM}, Ptr{Cvoid}), blkmem, ptr) + ccall( + (:BMSgetBlockPointerSize_call, libscip), + Csize_t, + (Ptr{BMS_BLKMEM}, Ptr{Cvoid}), + blkmem, + ptr, + ) end function BMSdisplayBlockMemory_call(blkmem) - ccall((:BMSdisplayBlockMemory_call, libscip), Cvoid, (Ptr{BMS_BLKMEM},), blkmem) + ccall( + (:BMSdisplayBlockMemory_call, libscip), + Cvoid, + (Ptr{BMS_BLKMEM},), + blkmem, + ) end function BMScheckEmptyBlockMemory_call(blkmem) - ccall((:BMScheckEmptyBlockMemory_call, libscip), Clonglong, (Ptr{BMS_BLKMEM},), blkmem) -end - -function BMScreateBufferMemory_call(arraygrowfac, arraygrowinit, clean, filename, line) - ccall((:BMScreateBufferMemory_call, libscip), Ptr{BMS_BUFMEM}, (Cdouble, Cint, Cuint, Ptr{Cchar}, Cint), arraygrowfac, arraygrowinit, clean, filename, line) + ccall( + (:BMScheckEmptyBlockMemory_call, libscip), + Clonglong, + (Ptr{BMS_BLKMEM},), + blkmem, + ) +end + +function BMScreateBufferMemory_call( + arraygrowfac, + arraygrowinit, + clean, + filename, + line, +) + ccall( + (:BMScreateBufferMemory_call, libscip), + Ptr{BMS_BUFMEM}, + (Cdouble, Cint, Cuint, Ptr{Cchar}, Cint), + arraygrowfac, + arraygrowinit, + clean, + filename, + line, + ) end function BMSdestroyBufferMemory_call(buffer, filename, line) - ccall((:BMSdestroyBufferMemory_call, libscip), Cvoid, (Ptr{Ptr{BMS_BUFMEM}}, Ptr{Cchar}, Cint), buffer, filename, line) + ccall( + (:BMSdestroyBufferMemory_call, libscip), + Cvoid, + (Ptr{Ptr{BMS_BUFMEM}}, Ptr{Cchar}, Cint), + buffer, + filename, + line, + ) end function BMSalignMemsize(size) @@ -25649,19 +80564,41 @@ function BMSisAligned(size) end function BMSsetBufferMemoryArraygrowfac(buffer, arraygrowfac) - ccall((:BMSsetBufferMemoryArraygrowfac, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Cdouble), buffer, arraygrowfac) + ccall( + (:BMSsetBufferMemoryArraygrowfac, libscip), + Cvoid, + (Ptr{BMS_BUFMEM}, Cdouble), + buffer, + arraygrowfac, + ) end function BMSsetBufferMemoryArraygrowinit(buffer, arraygrowinit) - ccall((:BMSsetBufferMemoryArraygrowinit, libscip), Cvoid, (Ptr{BMS_BUFMEM}, Cint), buffer, arraygrowinit) + ccall( + (:BMSsetBufferMemoryArraygrowinit, libscip), + Cvoid, + (Ptr{BMS_BUFMEM}, Cint), + buffer, + arraygrowinit, + ) end function BMSgetNUsedBufferMemory(buffer) - ccall((:BMSgetNUsedBufferMemory, libscip), Csize_t, (Ptr{BMS_BUFMEM},), buffer) + ccall( + (:BMSgetNUsedBufferMemory, libscip), + Csize_t, + (Ptr{BMS_BUFMEM},), + buffer, + ) end function BMSgetBufferMemoryUsed(buffer) - ccall((:BMSgetBufferMemoryUsed, libscip), Clonglong, (Ptr{BMS_BUFMEM},), buffer) + ccall( + (:BMSgetBufferMemoryUsed, libscip), + Clonglong, + (Ptr{BMS_BUFMEM},), + buffer, + ) end function BMSprintBufferMemory(buffer) @@ -25677,11 +80614,23 @@ function SCIPlpiGetSolverDesc() end function SCIPlpiGetSolverPointer(lpi) - ccall((:SCIPlpiGetSolverPointer, libscip), Ptr{Cvoid}, (Ptr{SCIP_LPI},), lpi) + ccall( + (:SCIPlpiGetSolverPointer, libscip), + Ptr{Cvoid}, + (Ptr{SCIP_LPI},), + lpi, + ) end function SCIPlpiSetIntegralityInformation(lpi, ncols, intInfo) - ccall((:SCIPlpiSetIntegralityInformation, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cint}), lpi, ncols, intInfo) + ccall( + (:SCIPlpiSetIntegralityInformation, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Ptr{Cint}), + lpi, + ncols, + intInfo, + ) end function SCIPlpiHasPrimalSolve() @@ -25704,39 +80653,172 @@ end const SCIP_OBJSEN = SCIP_ObjSen function SCIPlpiCreate(lpi, messagehdlr, name, objsen) - ccall((:SCIPlpiCreate, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LPI}}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, SCIP_OBJSEN), lpi, messagehdlr, name, objsen) + ccall( + (:SCIPlpiCreate, libscip), + SCIP_RETCODE, + (Ptr{Ptr{SCIP_LPI}}, Ptr{SCIP_MESSAGEHDLR}, Ptr{Cchar}, SCIP_OBJSEN), + lpi, + messagehdlr, + name, + objsen, + ) end function SCIPlpiFree(lpi) ccall((:SCIPlpiFree, libscip), SCIP_RETCODE, (Ptr{Ptr{SCIP_LPI}},), lpi) end -function SCIPlpiLoadColLP(lpi, objsen, ncols, obj, lb, ub, colnames, nrows, lhs, rhs, rownames, nnonz, beg, ind, val) - ccall((:SCIPlpiLoadColLP, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_OBJSEN, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, objsen, ncols, obj, lb, ub, colnames, nrows, lhs, rhs, rownames, nnonz, beg, ind, val) +function SCIPlpiLoadColLP( + lpi, + objsen, + ncols, + obj, + lb, + ub, + colnames, + nrows, + lhs, + rhs, + rownames, + nnonz, + beg, + ind, + val, +) + ccall( + (:SCIPlpiLoadColLP, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + SCIP_OBJSEN, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Ptr{Cchar}}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Ptr{Cchar}}, + Cint, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + ), + lpi, + objsen, + ncols, + obj, + lb, + ub, + colnames, + nrows, + lhs, + rhs, + rownames, + nnonz, + beg, + ind, + val, + ) end function SCIPlpiAddCols(lpi, ncols, obj, lb, ub, colnames, nnonz, beg, ind, val) - ccall((:SCIPlpiAddCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, ncols, obj, lb, ub, colnames, nnonz, beg, ind, val) + ccall( + (:SCIPlpiAddCols, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Ptr{Cchar}}, + Cint, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + ), + lpi, + ncols, + obj, + lb, + ub, + colnames, + nnonz, + beg, + ind, + val, + ) end function SCIPlpiDelCols(lpi, firstcol, lastcol) - ccall((:SCIPlpiDelCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint), lpi, firstcol, lastcol) + ccall( + (:SCIPlpiDelCols, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cint), + lpi, + firstcol, + lastcol, + ) end function SCIPlpiDelColset(lpi, dstat) - ccall((:SCIPlpiDelColset, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, dstat) + ccall( + (:SCIPlpiDelColset, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}), + lpi, + dstat, + ) end function SCIPlpiAddRows(lpi, nrows, lhs, rhs, rownames, nnonz, beg, ind, val) - ccall((:SCIPlpiAddRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Ptr{Cchar}}, Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, nrows, lhs, rhs, rownames, nnonz, beg, ind, val) + ccall( + (:SCIPlpiAddRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Ptr{Cchar}}, + Cint, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + ), + lpi, + nrows, + lhs, + rhs, + rownames, + nnonz, + beg, + ind, + val, + ) end function SCIPlpiDelRows(lpi, firstrow, lastrow) - ccall((:SCIPlpiDelRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint), lpi, firstrow, lastrow) + ccall( + (:SCIPlpiDelRows, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cint), + lpi, + firstrow, + lastrow, + ) end function SCIPlpiDelRowset(lpi, dstat) - ccall((:SCIPlpiDelRowset, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, dstat) + ccall( + (:SCIPlpiDelRowset, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}), + lpi, + dstat, + ) end function SCIPlpiClear(lpi) @@ -25744,79 +80826,291 @@ function SCIPlpiClear(lpi) end function SCIPlpiChgBounds(lpi, ncols, ind, lb, ub) - ccall((:SCIPlpiChgBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), lpi, ncols, ind, lb, ub) + ccall( + (:SCIPlpiChgBounds, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), + lpi, + ncols, + ind, + lb, + ub, + ) end function SCIPlpiChgSides(lpi, nrows, ind, lhs, rhs) - ccall((:SCIPlpiChgSides, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), lpi, nrows, ind, lhs, rhs) + ccall( + (:SCIPlpiChgSides, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}, Ptr{Cdouble}), + lpi, + nrows, + ind, + lhs, + rhs, + ) end function SCIPlpiChgCoef(lpi, row, col, newval) - ccall((:SCIPlpiChgCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Cdouble), lpi, row, col, newval) + ccall( + (:SCIPlpiChgCoef, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cint, Cdouble), + lpi, + row, + col, + newval, + ) end function SCIPlpiChgObjsen(lpi, objsen) - ccall((:SCIPlpiChgObjsen, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_OBJSEN), lpi, objsen) + ccall( + (:SCIPlpiChgObjsen, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, SCIP_OBJSEN), + lpi, + objsen, + ) end function SCIPlpiChgObj(lpi, ncols, ind, obj) - ccall((:SCIPlpiChgObj, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}), lpi, ncols, ind, obj) + ccall( + (:SCIPlpiChgObj, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Ptr{Cint}, Ptr{Cdouble}), + lpi, + ncols, + ind, + obj, + ) end function SCIPlpiScaleRow(lpi, row, scaleval) - ccall((:SCIPlpiScaleRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cdouble), lpi, row, scaleval) + ccall( + (:SCIPlpiScaleRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cdouble), + lpi, + row, + scaleval, + ) end function SCIPlpiScaleCol(lpi, col, scaleval) - ccall((:SCIPlpiScaleCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cdouble), lpi, col, scaleval) + ccall( + (:SCIPlpiScaleCol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cdouble), + lpi, + col, + scaleval, + ) end function SCIPlpiGetNRows(lpi, nrows) - ccall((:SCIPlpiGetNRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, nrows) + ccall( + (:SCIPlpiGetNRows, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}), + lpi, + nrows, + ) end function SCIPlpiGetNCols(lpi, ncols) - ccall((:SCIPlpiGetNCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, ncols) + ccall( + (:SCIPlpiGetNCols, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}), + lpi, + ncols, + ) end function SCIPlpiGetObjsen(lpi, objsen) - ccall((:SCIPlpiGetObjsen, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{SCIP_OBJSEN}), lpi, objsen) + ccall( + (:SCIPlpiGetObjsen, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{SCIP_OBJSEN}), + lpi, + objsen, + ) end function SCIPlpiGetNNonz(lpi, nnonz) - ccall((:SCIPlpiGetNNonz, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, nnonz) + ccall( + (:SCIPlpiGetNNonz, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}), + lpi, + nnonz, + ) end function SCIPlpiGetCols(lpi, firstcol, lastcol, lb, ub, nnonz, beg, ind, val) - ccall((:SCIPlpiGetCols, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, firstcol, lastcol, lb, ub, nnonz, beg, ind, val) + ccall( + (:SCIPlpiGetCols, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Cint, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + ), + lpi, + firstcol, + lastcol, + lb, + ub, + nnonz, + beg, + ind, + val, + ) end function SCIPlpiGetRows(lpi, firstrow, lastrow, lhs, rhs, nnonz, beg, ind, val) - ccall((:SCIPlpiGetRows, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cdouble}), lpi, firstrow, lastrow, lhs, rhs, nnonz, beg, ind, val) -end - -function SCIPlpiGetColNames(lpi, firstcol, lastcol, colnames, namestorage, namestoragesize, storageleft) - ccall((:SCIPlpiGetColNames, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}, Cint, Ptr{Cint}), lpi, firstcol, lastcol, colnames, namestorage, namestoragesize, storageleft) -end - -function SCIPlpiGetRowNames(lpi, firstrow, lastrow, rownames, namestorage, namestoragesize, storageleft) - ccall((:SCIPlpiGetRowNames, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Ptr{Cchar}}, Ptr{Cchar}, Cint, Ptr{Cint}), lpi, firstrow, lastrow, rownames, namestorage, namestoragesize, storageleft) + ccall( + (:SCIPlpiGetRows, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Cint, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cint}, + Ptr{Cdouble}, + ), + lpi, + firstrow, + lastrow, + lhs, + rhs, + nnonz, + beg, + ind, + val, + ) +end + +function SCIPlpiGetColNames( + lpi, + firstcol, + lastcol, + colnames, + namestorage, + namestoragesize, + storageleft, +) + ccall( + (:SCIPlpiGetColNames, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Cint, + Cint, + Ptr{Ptr{Cchar}}, + Ptr{Cchar}, + Cint, + Ptr{Cint}, + ), + lpi, + firstcol, + lastcol, + colnames, + namestorage, + namestoragesize, + storageleft, + ) +end + +function SCIPlpiGetRowNames( + lpi, + firstrow, + lastrow, + rownames, + namestorage, + namestoragesize, + storageleft, +) + ccall( + (:SCIPlpiGetRowNames, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Cint, + Cint, + Ptr{Ptr{Cchar}}, + Ptr{Cchar}, + Cint, + Ptr{Cint}, + ), + lpi, + firstrow, + lastrow, + rownames, + namestorage, + namestoragesize, + storageleft, + ) end function SCIPlpiGetObj(lpi, firstcol, lastcol, vals) - ccall((:SCIPlpiGetObj, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}), lpi, firstcol, lastcol, vals) + ccall( + (:SCIPlpiGetObj, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}), + lpi, + firstcol, + lastcol, + vals, + ) end function SCIPlpiGetBounds(lpi, firstcol, lastcol, lbs, ubs) - ccall((:SCIPlpiGetBounds, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), lpi, firstcol, lastcol, lbs, ubs) + ccall( + (:SCIPlpiGetBounds, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), + lpi, + firstcol, + lastcol, + lbs, + ubs, + ) end function SCIPlpiGetSides(lpi, firstrow, lastrow, lhss, rhss) - ccall((:SCIPlpiGetSides, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), lpi, firstrow, lastrow, lhss, rhss) + ccall( + (:SCIPlpiGetSides, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}, Ptr{Cdouble}), + lpi, + firstrow, + lastrow, + lhss, + rhss, + ) end function SCIPlpiGetCoef(lpi, row, col, val) - ccall((:SCIPlpiGetCoef, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}), lpi, row, col, val) + ccall( + (:SCIPlpiGetCoef, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Cint, Ptr{Cdouble}), + lpi, + row, + col, + val, + ) end function SCIPlpiSolvePrimal(lpi) @@ -25828,31 +81122,185 @@ function SCIPlpiSolveDual(lpi) end function SCIPlpiSolveBarrier(lpi, crossover) - ccall((:SCIPlpiSolveBarrier, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cuint), lpi, crossover) + ccall( + (:SCIPlpiSolveBarrier, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cuint), + lpi, + crossover, + ) end function SCIPlpiStartStrongbranch(lpi) - ccall((:SCIPlpiStartStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI},), lpi) + ccall( + (:SCIPlpiStartStrongbranch, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI},), + lpi, + ) end function SCIPlpiEndStrongbranch(lpi) - ccall((:SCIPlpiEndStrongbranch, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI},), lpi) -end - -function SCIPlpiStrongbranchFrac(lpi, col, psol, itlim, down, up, downvalid, upvalid, iter) - ccall((:SCIPlpiStrongbranchFrac, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cdouble, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}), lpi, col, psol, itlim, down, up, downvalid, upvalid, iter) -end - -function SCIPlpiStrongbranchesFrac(lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter) - ccall((:SCIPlpiStrongbranchesFrac, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}, Cint, Ptr{Cdouble}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}), lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter) -end - -function SCIPlpiStrongbranchInt(lpi, col, psol, itlim, down, up, downvalid, upvalid, iter) - ccall((:SCIPlpiStrongbranchInt, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Cdouble, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}), lpi, col, psol, itlim, down, up, downvalid, upvalid, iter) -end - -function SCIPlpiStrongbranchesInt(lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter) - ccall((:SCIPlpiStrongbranchesInt, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}, Cint, Ptr{Cdouble}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cuint}, Ptr{Cuint}, Ptr{Cint}), lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter) + ccall( + (:SCIPlpiEndStrongbranch, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI},), + lpi, + ) +end + +function SCIPlpiStrongbranchFrac( + lpi, + col, + psol, + itlim, + down, + up, + downvalid, + upvalid, + iter, +) + ccall( + (:SCIPlpiStrongbranchFrac, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Cint, + Cdouble, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cint}, + ), + lpi, + col, + psol, + itlim, + down, + up, + downvalid, + upvalid, + iter, + ) +end + +function SCIPlpiStrongbranchesFrac( + lpi, + cols, + ncols, + psols, + itlim, + down, + up, + downvalid, + upvalid, + iter, +) + ccall( + (:SCIPlpiStrongbranchesFrac, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Ptr{Cint}, + Cint, + Ptr{Cdouble}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cint}, + ), + lpi, + cols, + ncols, + psols, + itlim, + down, + up, + downvalid, + upvalid, + iter, + ) +end + +function SCIPlpiStrongbranchInt( + lpi, + col, + psol, + itlim, + down, + up, + downvalid, + upvalid, + iter, +) + ccall( + (:SCIPlpiStrongbranchInt, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Cint, + Cdouble, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cint}, + ), + lpi, + col, + psol, + itlim, + down, + up, + downvalid, + upvalid, + iter, + ) +end + +function SCIPlpiStrongbranchesInt( + lpi, + cols, + ncols, + psols, + itlim, + down, + up, + downvalid, + upvalid, + iter, +) + ccall( + (:SCIPlpiStrongbranchesInt, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Ptr{Cint}, + Cint, + Ptr{Cdouble}, + Cint, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cuint}, + Ptr{Cuint}, + Ptr{Cint}, + ), + lpi, + cols, + ncols, + psols, + itlim, + down, + up, + downvalid, + upvalid, + iter, + ) end function SCIPlpiWasSolved(lpi) @@ -25860,7 +81308,14 @@ function SCIPlpiWasSolved(lpi) end function SCIPlpiGetSolFeasibility(lpi, primalfeasible, dualfeasible) - ccall((:SCIPlpiGetSolFeasibility, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cuint}, Ptr{Cuint}), lpi, primalfeasible, dualfeasible) + ccall( + (:SCIPlpiGetSolFeasibility, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cuint}, Ptr{Cuint}), + lpi, + primalfeasible, + dualfeasible, + ) end function SCIPlpiExistsPrimalRay(lpi) @@ -25928,27 +81383,74 @@ function SCIPlpiGetInternalStatus(lpi) end function SCIPlpiIgnoreInstability(lpi, success) - ccall((:SCIPlpiIgnoreInstability, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cuint}), lpi, success) + ccall( + (:SCIPlpiIgnoreInstability, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cuint}), + lpi, + success, + ) end function SCIPlpiGetObjval(lpi, objval) - ccall((:SCIPlpiGetObjval, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cdouble}), lpi, objval) + ccall( + (:SCIPlpiGetObjval, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cdouble}), + lpi, + objval, + ) end function SCIPlpiGetSol(lpi, objval, primsol, dualsol, activity, redcost) - ccall((:SCIPlpiGetSol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), lpi, objval, primsol, dualsol, activity, redcost) + ccall( + (:SCIPlpiGetSol, libscip), + SCIP_RETCODE, + ( + Ptr{SCIP_LPI}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + Ptr{Cdouble}, + ), + lpi, + objval, + primsol, + dualsol, + activity, + redcost, + ) end function SCIPlpiGetPrimalRay(lpi, ray) - ccall((:SCIPlpiGetPrimalRay, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cdouble}), lpi, ray) + ccall( + (:SCIPlpiGetPrimalRay, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cdouble}), + lpi, + ray, + ) end function SCIPlpiGetDualfarkas(lpi, dualfarkas) - ccall((:SCIPlpiGetDualfarkas, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cdouble}), lpi, dualfarkas) + ccall( + (:SCIPlpiGetDualfarkas, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cdouble}), + lpi, + dualfarkas, + ) end function SCIPlpiGetIterations(lpi, iterations) - ccall((:SCIPlpiGetIterations, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, iterations) + ccall( + (:SCIPlpiGetIterations, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}), + lpi, + iterations, + ) end @enum SCIP_LPSolQuality::UInt32 begin @@ -25959,43 +81461,121 @@ end const SCIP_LPSOLQUALITY = SCIP_LPSolQuality function SCIPlpiGetRealSolQuality(lpi, qualityindicator, quality) - ccall((:SCIPlpiGetRealSolQuality, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPSOLQUALITY, Ptr{Cdouble}), lpi, qualityindicator, quality) + ccall( + (:SCIPlpiGetRealSolQuality, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, SCIP_LPSOLQUALITY, Ptr{Cdouble}), + lpi, + qualityindicator, + quality, + ) end function SCIPlpiGetBase(lpi, cstat, rstat) - ccall((:SCIPlpiGetBase, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}, Ptr{Cint}), lpi, cstat, rstat) + ccall( + (:SCIPlpiGetBase, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}, Ptr{Cint}), + lpi, + cstat, + rstat, + ) end function SCIPlpiSetBase(lpi, cstat, rstat) - ccall((:SCIPlpiSetBase, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}, Ptr{Cint}), lpi, cstat, rstat) + ccall( + (:SCIPlpiSetBase, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}, Ptr{Cint}), + lpi, + cstat, + rstat, + ) end function SCIPlpiGetBasisInd(lpi, bind) - ccall((:SCIPlpiGetBasisInd, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cint}), lpi, bind) + ccall( + (:SCIPlpiGetBasisInd, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cint}), + lpi, + bind, + ) end function SCIPlpiGetBInvRow(lpi, r, coef, inds, ninds) - ccall((:SCIPlpiGetBInvRow, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lpi, r, coef, inds, ninds) + ccall( + (:SCIPlpiGetBInvRow, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + lpi, + r, + coef, + inds, + ninds, + ) end function SCIPlpiGetBInvCol(lpi, c, coef, inds, ninds) - ccall((:SCIPlpiGetBInvCol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lpi, c, coef, inds, ninds) + ccall( + (:SCIPlpiGetBInvCol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + lpi, + c, + coef, + inds, + ninds, + ) end function SCIPlpiGetBInvARow(lpi, r, binvrow, coef, inds, ninds) - ccall((:SCIPlpiGetBInvARow, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lpi, r, binvrow, coef, inds, ninds) + ccall( + (:SCIPlpiGetBInvARow, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + lpi, + r, + binvrow, + coef, + inds, + ninds, + ) end function SCIPlpiGetBInvACol(lpi, c, coef, inds, ninds) - ccall((:SCIPlpiGetBInvACol, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), lpi, c, coef, inds, ninds) + ccall( + (:SCIPlpiGetBInvACol, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cint, Ptr{Cdouble}, Ptr{Cint}, Ptr{Cint}), + lpi, + c, + coef, + inds, + ninds, + ) end function SCIPlpiGetState(lpi, blkmem, lpistate) - ccall((:SCIPlpiGetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lpi, blkmem, lpistate) + ccall( + (:SCIPlpiGetState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), + lpi, + blkmem, + lpistate, + ) end function SCIPlpiSetState(lpi, blkmem, lpistate) - ccall((:SCIPlpiSetState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPISTATE}), lpi, blkmem, lpistate) + ccall( + (:SCIPlpiSetState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPISTATE}), + lpi, + blkmem, + lpistate, + ) end function SCIPlpiClearState(lpi) @@ -26003,31 +81583,77 @@ function SCIPlpiClearState(lpi) end function SCIPlpiFreeState(lpi, blkmem, lpistate) - ccall((:SCIPlpiFreeState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), lpi, blkmem, lpistate) + ccall( + (:SCIPlpiFreeState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPISTATE}}), + lpi, + blkmem, + lpistate, + ) end function SCIPlpiHasStateBasis(lpi, lpistate) - ccall((:SCIPlpiHasStateBasis, libscip), Cuint, (Ptr{SCIP_LPI}, Ptr{SCIP_LPISTATE}), lpi, lpistate) + ccall( + (:SCIPlpiHasStateBasis, libscip), + Cuint, + (Ptr{SCIP_LPI}, Ptr{SCIP_LPISTATE}), + lpi, + lpistate, + ) end function SCIPlpiReadState(lpi, fname) - ccall((:SCIPlpiReadState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cchar}), lpi, fname) + ccall( + (:SCIPlpiReadState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cchar}), + lpi, + fname, + ) end function SCIPlpiWriteState(lpi, fname) - ccall((:SCIPlpiWriteState, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cchar}), lpi, fname) + ccall( + (:SCIPlpiWriteState, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cchar}), + lpi, + fname, + ) end function SCIPlpiGetNorms(lpi, blkmem, lpinorms) - ccall((:SCIPlpiGetNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), lpi, blkmem, lpinorms) + ccall( + (:SCIPlpiGetNorms, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), + lpi, + blkmem, + lpinorms, + ) end function SCIPlpiSetNorms(lpi, blkmem, lpinorms) - ccall((:SCIPlpiSetNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPINORMS}), lpi, blkmem, lpinorms) + ccall( + (:SCIPlpiSetNorms, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{SCIP_LPINORMS}), + lpi, + blkmem, + lpinorms, + ) end function SCIPlpiFreeNorms(lpi, blkmem, lpinorms) - ccall((:SCIPlpiFreeNorms, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), lpi, blkmem, lpinorms) + ccall( + (:SCIPlpiFreeNorms, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{BMS_BLKMEM}, Ptr{Ptr{SCIP_LPINORMS}}), + lpi, + blkmem, + lpinorms, + ) end @enum SCIP_LPParam::UInt32 begin @@ -26056,23 +81682,57 @@ end const SCIP_LPPARAM = SCIP_LPParam function SCIPlpiGetIntpar(lpi, type, ival) - ccall((:SCIPlpiGetIntpar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPPARAM, Ptr{Cint}), lpi, type, ival) + ccall( + (:SCIPlpiGetIntpar, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, SCIP_LPPARAM, Ptr{Cint}), + lpi, + type, + ival, + ) end function SCIPlpiSetIntpar(lpi, type, ival) - ccall((:SCIPlpiSetIntpar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPPARAM, Cint), lpi, type, ival) + ccall( + (:SCIPlpiSetIntpar, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, SCIP_LPPARAM, Cint), + lpi, + type, + ival, + ) end function SCIPlpiGetRealpar(lpi, type, dval) - ccall((:SCIPlpiGetRealpar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPPARAM, Ptr{Cdouble}), lpi, type, dval) + ccall( + (:SCIPlpiGetRealpar, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, SCIP_LPPARAM, Ptr{Cdouble}), + lpi, + type, + dval, + ) end function SCIPlpiSetRealpar(lpi, type, dval) - ccall((:SCIPlpiSetRealpar, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, SCIP_LPPARAM, Cdouble), lpi, type, dval) + ccall( + (:SCIPlpiSetRealpar, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, SCIP_LPPARAM, Cdouble), + lpi, + type, + dval, + ) end function SCIPlpiInterrupt(lpi, interrupt) - ccall((:SCIPlpiInterrupt, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Cuint), lpi, interrupt) + ccall( + (:SCIPlpiInterrupt, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Cuint), + lpi, + interrupt, + ) end function SCIPlpiInfinity(lpi) @@ -26080,15 +81740,33 @@ function SCIPlpiInfinity(lpi) end function SCIPlpiIsInfinity(lpi, val) - ccall((:SCIPlpiIsInfinity, libscip), Cuint, (Ptr{SCIP_LPI}, Cdouble), lpi, val) + ccall( + (:SCIPlpiIsInfinity, libscip), + Cuint, + (Ptr{SCIP_LPI}, Cdouble), + lpi, + val, + ) end function SCIPlpiReadLP(lpi, fname) - ccall((:SCIPlpiReadLP, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cchar}), lpi, fname) + ccall( + (:SCIPlpiReadLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cchar}), + lpi, + fname, + ) end function SCIPlpiWriteLP(lpi, fname) - ccall((:SCIPlpiWriteLP, libscip), SCIP_RETCODE, (Ptr{SCIP_LPI}, Ptr{Cchar}), lpi, fname) + ccall( + (:SCIPlpiWriteLP, libscip), + SCIP_RETCODE, + (Ptr{SCIP_LPI}, Ptr{Cchar}), + lpi, + fname, + ) end # Skipping MacroDefinition: SCIP_EXPORT __attribute__ ( ( visibility ( "default" ) ) ) @@ -26185,45 +81863,86 @@ const SCIP_EVENTTYPE_ROWSIDECHANGED = UINT64_C(0x0000000800000000) const SCIP_EVENTTYPE_SYNC = UINT64_C(0x0000001000000000) -const SCIP_EVENTTYPE_GBDCHANGED = SCIP_EVENTTYPE_GLBCHANGED | SCIP_EVENTTYPE_GUBCHANGED +const SCIP_EVENTTYPE_GBDCHANGED = + SCIP_EVENTTYPE_GLBCHANGED | SCIP_EVENTTYPE_GUBCHANGED -const SCIP_EVENTTYPE_LBCHANGED = SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED +const SCIP_EVENTTYPE_LBCHANGED = + SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED -const SCIP_EVENTTYPE_UBCHANGED = SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_UBRELAXED +const SCIP_EVENTTYPE_UBCHANGED = + SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_UBRELAXED -const SCIP_EVENTTYPE_BOUNDTIGHTENED = SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_UBTIGHTENED +const SCIP_EVENTTYPE_BOUNDTIGHTENED = + SCIP_EVENTTYPE_LBTIGHTENED | SCIP_EVENTTYPE_UBTIGHTENED -const SCIP_EVENTTYPE_BOUNDRELAXED = SCIP_EVENTTYPE_LBRELAXED | SCIP_EVENTTYPE_UBRELAXED +const SCIP_EVENTTYPE_BOUNDRELAXED = + SCIP_EVENTTYPE_LBRELAXED | SCIP_EVENTTYPE_UBRELAXED -const SCIP_EVENTTYPE_BOUNDCHANGED = SCIP_EVENTTYPE_LBCHANGED | SCIP_EVENTTYPE_UBCHANGED +const SCIP_EVENTTYPE_BOUNDCHANGED = + SCIP_EVENTTYPE_LBCHANGED | SCIP_EVENTTYPE_UBCHANGED -const SCIP_EVENTTYPE_GHOLECHANGED = SCIP_EVENTTYPE_GHOLEADDED | SCIP_EVENTTYPE_GHOLEREMOVED +const SCIP_EVENTTYPE_GHOLECHANGED = + SCIP_EVENTTYPE_GHOLEADDED | SCIP_EVENTTYPE_GHOLEREMOVED -const SCIP_EVENTTYPE_LHOLECHANGED = SCIP_EVENTTYPE_LHOLEADDED | SCIP_EVENTTYPE_LHOLEREMOVED +const SCIP_EVENTTYPE_LHOLECHANGED = + SCIP_EVENTTYPE_LHOLEADDED | SCIP_EVENTTYPE_LHOLEREMOVED -const SCIP_EVENTTYPE_HOLECHANGED = SCIP_EVENTTYPE_GHOLECHANGED | SCIP_EVENTTYPE_LHOLECHANGED +const SCIP_EVENTTYPE_HOLECHANGED = + SCIP_EVENTTYPE_GHOLECHANGED | SCIP_EVENTTYPE_LHOLECHANGED -const SCIP_EVENTTYPE_DOMCHANGED = SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_HOLECHANGED +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) | SCIP_EVENTTYPE_TYPECHANGED) | SCIP_EVENTTYPE_IMPLTYPECHANGED +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 + ) | SCIP_EVENTTYPE_TYPECHANGED + ) | SCIP_EVENTTYPE_IMPLTYPECHANGED -const SCIP_EVENTTYPE_VAREVENT = SCIP_EVENTTYPE_VARADDED | SCIP_EVENTTYPE_VARCHANGED +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_NODESOLVED = + (SCIP_EVENTTYPE_NODEFEASIBLE | SCIP_EVENTTYPE_NODEINFEASIBLE) | + SCIP_EVENTTYPE_NODEBRANCHED -const SCIP_EVENTTYPE_NODEEVENT = SCIP_EVENTTYPE_NODEFOCUSED | SCIP_EVENTTYPE_NODESOLVED +const SCIP_EVENTTYPE_NODEEVENT = + SCIP_EVENTTYPE_NODEFOCUSED | SCIP_EVENTTYPE_NODESOLVED -const SCIP_EVENTTYPE_LPEVENT = SCIP_EVENTTYPE_FIRSTLPSOLVED | SCIP_EVENTTYPE_LPSOLVED +const SCIP_EVENTTYPE_LPEVENT = + SCIP_EVENTTYPE_FIRSTLPSOLVED | SCIP_EVENTTYPE_LPSOLVED -const SCIP_EVENTTYPE_SOLFOUND = SCIP_EVENTTYPE_POORSOLFOUND | SCIP_EVENTTYPE_BESTSOLFOUND +const SCIP_EVENTTYPE_SOLFOUND = + SCIP_EVENTTYPE_POORSOLFOUND | SCIP_EVENTTYPE_BESTSOLFOUND const SCIP_EVENTTYPE_SOLEVENT = SCIP_EVENTTYPE_SOLFOUND -const SCIP_EVENTTYPE_GAPUPDATED = SCIP_EVENTTYPE_BESTSOLFOUND | SCIP_EVENTTYPE_DUALBOUNDIMPROVED +const SCIP_EVENTTYPE_GAPUPDATED = + SCIP_EVENTTYPE_BESTSOLFOUND | SCIP_EVENTTYPE_DUALBOUNDIMPROVED -const SCIP_EVENTTYPE_ROWCHANGED = (SCIP_EVENTTYPE_ROWCOEFCHANGED | SCIP_EVENTTYPE_ROWCONSTCHANGED) | SCIP_EVENTTYPE_ROWSIDECHANGED +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_ROWEVENT = + ( + ( + (SCIP_EVENTTYPE_ROWADDEDSEPA | SCIP_EVENTTYPE_ROWDELETEDSEPA) | + SCIP_EVENTTYPE_ROWADDEDLP + ) | SCIP_EVENTTYPE_ROWDELETEDLP + ) | SCIP_EVENTTYPE_ROWCHANGED const SCIP_EVENTTYPE_FORMAT = PRIx64 @@ -26239,7 +81958,11 @@ const SCIP_EXPRITER_VISITEDCHILD = Cuint(4) const SCIP_EXPRITER_LEAVEEXPR = Cuint(8) -const SCIP_EXPRITER_ALLSTAGES = ((SCIP_EXPRITER_ENTEREXPR | SCIP_EXPRITER_VISITINGCHILD) | SCIP_EXPRITER_VISITEDCHILD) | SCIP_EXPRITER_LEAVEEXPR +const SCIP_EXPRITER_ALLSTAGES = + ( + (SCIP_EXPRITER_ENTEREXPR | SCIP_EXPRITER_VISITINGCHILD) | + SCIP_EXPRITER_VISITEDCHILD + ) | SCIP_EXPRITER_LEAVEEXPR const SCIP_EXPRPRINT_EXPRSTRING = Cuint(0x01) @@ -26257,7 +81980,15 @@ const SCIP_EXPRPRINT_ACTIVITYTAG = Cuint(0x60) const SCIP_EXPRPRINT_OWNER = Cuint(0x80) -const SCIP_EXPRPRINT_ALL = ((((SCIP_EXPRPRINT_EXPRSTRING | SCIP_EXPRPRINT_EXPRHDLR) | SCIP_EXPRPRINT_NUSES) | SCIP_EXPRPRINT_EVALTAG) | SCIP_EXPRPRINT_ACTIVITYTAG) | SCIP_EXPRPRINT_OWNER +const SCIP_EXPRPRINT_ALL = + ( + ( + ( + (SCIP_EXPRPRINT_EXPRSTRING | SCIP_EXPRPRINT_EXPRHDLR) | + SCIP_EXPRPRINT_NUSES + ) | SCIP_EXPRPRINT_EVALTAG + ) | SCIP_EXPRPRINT_ACTIVITYTAG + ) | SCIP_EXPRPRINT_OWNER const SCIP_EXPRINTCAPABILITY_NONE = 0x00000000 @@ -26267,7 +81998,9 @@ const SCIP_EXPRINTCAPABILITY_GRADIENT = 0x00000010 const SCIP_EXPRINTCAPABILITY_HESSIAN = 0x00000100 -const SCIP_EXPRINTCAPABILITY_ALL = (SCIP_EXPRINTCAPABILITY_FUNCVALUE | SCIP_EXPRINTCAPABILITY_GRADIENT) | SCIP_EXPRINTCAPABILITY_HESSIAN +const SCIP_EXPRINTCAPABILITY_ALL = + (SCIP_EXPRINTCAPABILITY_FUNCVALUE | SCIP_EXPRINTCAPABILITY_GRADIENT) | + SCIP_EXPRINTCAPABILITY_HESSIAN const SCIP_DIVETYPE_NONE = Cuint(0x0000) @@ -26295,11 +82028,13 @@ const SCIP_NLHDLR_METHOD_SEPABELOW = Cuint(0x01) const SCIP_NLHDLR_METHOD_SEPAABOVE = Cuint(0x02) -const SCIP_NLHDLR_METHOD_SEPABOTH = SCIP_NLHDLR_METHOD_SEPABELOW | SCIP_NLHDLR_METHOD_SEPAABOVE +const SCIP_NLHDLR_METHOD_SEPABOTH = + SCIP_NLHDLR_METHOD_SEPABELOW | SCIP_NLHDLR_METHOD_SEPAABOVE const SCIP_NLHDLR_METHOD_ACTIVITY = Cuint(0x04) -const SCIP_NLHDLR_METHOD_ALL = SCIP_NLHDLR_METHOD_SEPABOTH | SCIP_NLHDLR_METHOD_ACTIVITY +const SCIP_NLHDLR_METHOD_ALL = + SCIP_NLHDLR_METHOD_SEPABOTH | SCIP_NLHDLR_METHOD_ACTIVITY const SCIP_NLPPARAM_DEFAULT_VERBLEVEL = 0 @@ -26319,9 +82054,15 @@ const SCIP_PRESOLTIMING_EXHAUSTIVE = Cuint(0x0010) const SCIP_PRESOLTIMING_FINAL = Cuint(0x0020) -const SCIP_PRESOLTIMING_ALWAYS = (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM) | SCIP_PRESOLTIMING_EXHAUSTIVE +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_PRESOLTIMING_MAX = + ( + (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM) | + SCIP_PRESOLTIMING_EXHAUSTIVE + ) | SCIP_PRESOLTIMING_FINAL const SCIP_PROPTIMING_NONE = Cuint(0x0000) @@ -26333,7 +82074,11 @@ const SCIP_PROPTIMING_AFTERLPLOOP = Cuint(0x0004) const SCIP_PROPTIMING_AFTERLPNODE = Cuint(0x0008) -const SCIP_PROPTIMING_ALWAYS = ((SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP) | SCIP_PROPTIMING_AFTERLPLOOP) | SCIP_PROPTIMING_AFTERLPNODE +const SCIP_PROPTIMING_ALWAYS = + ( + (SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP) | + SCIP_PROPTIMING_AFTERLPLOOP + ) | SCIP_PROPTIMING_AFTERLPNODE const SCIP_HEURTIMING_NONE = Cuint(0x0000) @@ -26359,9 +82104,11 @@ const SCIP_HEURTIMING_DURINGPRESOLLOOP = Cuint(0x0200) const SCIP_HEURTIMING_AFTERPROPLOOP = Cuint(0x0400) -const SCIP_HEURTIMING_AFTERNODE = SCIP_HEURTIMING_AFTERLPNODE | SCIP_HEURTIMING_AFTERPSEUDONODE +const SCIP_HEURTIMING_AFTERNODE = + SCIP_HEURTIMING_AFTERLPNODE | SCIP_HEURTIMING_AFTERPSEUDONODE -const SCIP_HEURTIMING_AFTERPLUNGE = SCIP_HEURTIMING_AFTERLPPLUNGE | SCIP_HEURTIMING_AFTERPSEUDOPLUNGE +const SCIP_HEURTIMING_AFTERPLUNGE = + SCIP_HEURTIMING_AFTERLPPLUNGE | SCIP_HEURTIMING_AFTERPSEUDOPLUNGE const SCIP_DEPRECATED_VARTYPE_IMPLINT = SCIP_VARTYPE(2) @@ -26387,7 +82134,8 @@ const SCIP_VERSION_MINOR = 0 const SCIP_VERSION_PATCH = 0 -const SCIP_VERSION = 100SCIP_VERSION_MAJOR + 10SCIP_VERSION_MINOR + SCIP_VERSION_PATCH +const SCIP_VERSION = + 100SCIP_VERSION_MAJOR + 10SCIP_VERSION_MINOR + SCIP_VERSION_PATCH const SCIP_VERSION_SUB = 0