Reference of C++ interface

CBAFTData(start_modification_id::Integer = 0)

calls clear()

CBAFTModel(in_model::Union{<:CBSumBlockModel,Nothing}, inaft::Union{<:CBAffineFunctionTransformation,Nothing} = nothing, start_modification_id::Integer = 0, in_model_is_owner::Bool = false)

sets @a model to @a inmodel and @a modelisowner to @a inmodelisowner (or false if @a inmodel==0) and calls clear with parameters (inaft,startmodification_id)

CBAFTModification(var_olddim::Integer = 0, row_olddim::Integer = 0, ignore_groundset_modification::Bool = false)

initialize and reset to an unmodified object currently having varolddim columns and rowolddim rows

CBAffineFunctionTransformation(in_fun_coeff::Real = 1., in_fun_offset::Real = 0., in_linear_cost::Union{<:CBMatrix,Nothing} = nothing, in_arg_offset::Union{<:CBMatrix,Nothing} = nothing, in_arg_trafo::Union{<:CBSparsemat,Nothing} = nothing, in_model_calls_delete::Bool = true, incr::Integer = -1)

calls init()

CBBlockPSCPrimal(pr::CBBlockPSCPrimal, factor::Real = 1.)

copy constructor

CBBoxData(fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function)

initializes BundleData, sets center_primal to NULL and calls clear()

CBBoxModel(fo::Union{<:CBBoxOracle,Nothing}, fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function, cbinc::Integer = -1)

construct a model for the MatrixBoxOracle pointed to by @a fo

CBBoxModelParameters(cbinc::Integer = -1)

default constructor

CBBoxModelParameters(bp::CBBundleParameters, cbinc::Integer = -1)

copy constructor for BundleParameters

CBBoxModelParameters(sms::CBBoxModelParameters)

copy constructor

CBBoxOracle(in_lb::CBMatrix, in_ub::CBMatrix)

constructor initializing lower and upper bounds (must have the same dimesnion, not checked)

CBBundleDLRTrustRegionProx(dim::Integer = 0, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_metric::Bool = false, inc::Integer = -1)

default constructor with empty H (equal to zero) and the dimension as argument

CBBundleDLRTrustRegionProx(in_D::CBMatrix, in_vecH::CBMatrix, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_metric::Bool = false, inc::Integer = -1)

constructs H=(D+weightu)+vecH*transpose(vecH) with weightu=1., so inD must be a column vector with same dimension as rows in invecH

CBBundleDenseTrustRegionProx(Hin::CBSymmatrix, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_metric::Bool = false, bounds_scaling::Bool = false, cbinc::Integer = -1)

initialize to this Matrix and set the variable_metric option (false by default)

CBBundleDenseTrustRegionProx(dim::Integer = 0, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_metric::Bool = false, bounds_scaling::Bool = false, cbinc::Integer = -1)

initialize H to the zero Matrix of this dimension (on the diagonal the weight will be added) and set the variable_metric option (false by default)

CBBundleDiagonalTrustRegionProx(Din::CBMatrix, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_scaling::Bool = false, bounds_scaling::Bool = false, cbinc::Integer = -1)

initialize to this diagonal matrix

CBBundleDiagonalTrustRegionProx(dim::Integer, d::Real, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_scaling::Bool = false, bounds_scaling::Bool = false, cbinc::Integer = -1)

initialize to a diaognal matrix d*identity of dimesion dim

CBBundleDiagonalTrustRegionProx(dim::Integer = 0, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_scaling::Bool = false, bounds_scaling::Bool = false, cbinc::Integer = -1)

initialize to a zero diaognal matrix of dimesion dim

CBBundleHKWeight(mRin::Real = .5, bwp::Union{<:CBBundleWeight,Nothing} = nothing, incr::Integer = -1)

the parameter mRin gets the value for accepting descent steps, bwp may be used to communicate the previous values use by another routine

CBBundleIdProx(d::Integer = 0, w::Real = 1., cbinc::Integer = -1)

initialize with dimension and weight

CBBundleLowRankTrustRegionProx(dim::Integer = 0, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_metric::Bool = false, inc::Integer = -1)

default constructor with empty H (equal to zero) and the dimension as argument

CBBundleLowRankTrustRegionProx(in_vecH::CBMatrix, in_lamH::CBMatrix, vp::Union{<:CBVariableMetricSelection,Nothing} = nothing, local_metric::Bool = false, inc::Integer = -1)

constructs H=vecHDiag(lamH)transpose(vecH), so inlamH must be a column vector with same dimension as columns in invecH and the row dimension of invecH must match the design space, invecH is assumed orthogonal

CBBundleRQBWeight(bwp::Union{<:CBBundleWeight,Nothing} = nothing, incr::Integer = -1)

bwp may be used to communicate the previous values used by another routine

CBBundleRQBWeight(m1::Real, m2::Real = .2, m3::Real = 1., eta::Real = 1e-6, bwp::Union{<:CBBundleWeight,Nothing} = nothing, incr::Integer = -1)

bwp may be used to communicate the previous values used by another routine

CBBundleSolver(dim::Integer, bp::Union{<:CBBundleModel,Nothing} = nothing, incr::Integer = -1)

calls initialize(CHMatrixClasses::Integer, BundleModel*)

CBBundleSolver(gs::Union{<:CBGroundset,Nothing}, bp::Union{<:CBBundleModel,Nothing} = nothing, incr::Integer = -1)

calls initialize(Groundset,BundleModel)

CBBundleTerminator(incr::Integer = -1)

calls set_defaults() and clear()

CBCFunction(fk::Union{<:AbstractVector{Nothing},Nothing}, fp::Ptr{Cvoid}, se::Ptr{Cvoid} = 0, prdim::Integer = 0)

constructor

CBCFunctionMinorantExtender(fk::Union{<:AbstractVector{Nothing},Nothing}, se::Ptr{Cvoid})

constructor

CBCMgramdense(Ain::CBMatrix, pos::Bool = true, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

copy Ain and possibly, the flag for positive/negative and store the user information

CBCMgramsparse(Ain::CBSparsemat, pos::Bool = true, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

copy Ain, the flag for positive/negative and store the user information

CBCMgramsparse_withoutdiag(Ain::CBSparsemat, pos::Bool = true, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

copy Ain, the flag for positive/negative and store the user information

CBCMlowrankdd(Ain::CBMatrix, Bin::CBMatrix, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

copy Ain, Bin and store the user information

CBCMlowranksd(Ain::CBSparsemat, Bin::CBMatrix, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

copy Ain, Bin and store the user information

CBCMlowrankss(Ain::CBSparsemat, Bin::CBSparsemat, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

copy Ain, Bin and store the user information

CBCMsingleton(innr::Integer, ini::Integer, inj::Integer, inval::Real, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

the order is innr and the nonzero element (ini,inj) has values inval

CBCMsymdense(Ain::CBSymmatrix, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

copy Ain and possibly store the user information

CBCMsymsparse(Ain::CBSparsesym, cip::Union{<:CBCoeffmatInfo,Nothing} = nothing)

copy Ain and possibly store the user information, set use_sparsemult to true if at least half the rows will be zero

CBClock()

calls start()

CBCoeffmatInfo(sf::Real = 1.)

default value is 1 for no scaling

CBDensePSCPrimal()

initialize to a symmetric matrix of size 0

CBDensePSCPrimal(symmat::CBDensePSCPrimal, factor::Real = 1.)

copy constructor

CBDensePSCPrimal(symmat::CBSymmatrix, factor::Real = 1.)

copy constructor from a CHMatrixClasses::Symmatrix

CBDensePSCPrimal(n::Integer)

direct size initialization to a zero matrix

CBGB_rand(seed::Integer = 1)

calls init(seed)

CBGramSparsePSCPrimal(sps::CBSparsesym, factor::Real = 1.)

initialize to the given sparse symmetric matrix, the gram part is zero

CBGramSparsePSCPrimal(pr::CBGramSparsePSCPrimal, factor::Real = 1.)

copy constructor

CBGroundsetModification(var_olddim::Integer = 0, incr::Integer = -1)

constructor, calls modification constructor

CBIndexmatrix()

empty matrix

CBIndexmatrix(A::CBIndexmatrix, d::Integer = 1)

copy constructor, this=dA

CBIndexmatrix(param0::AbstractRange{<:Integer})

generate a column vector holding the indices of this #CHMatrixClasses::Range

CBIndexmatrix(nr::Integer, nc::Integer)

• @brief generate a matrix of size nr x nc but WITHOUT initializing the memory

    If initializing the memory externally and CONICBUNDLE_DEBUG is defined, please use
    set_init() via matrix.set_init(true) in order to avoid warnings concerning improper
    initialization

CBIndexmatrix(nr::Integer, nc::Integer, d::Integer)

generate a matrix of size nr x nc initializing all elements to the value d

CBIndexmatrix(nr::Integer, nc::Integer, dp::Union{<:AbstractVector{Cint},Nothing})

generate a matrix of size nr x nc initializing the elements from the (one dimensional) array dp with increment incr

CBIndexmatrix(param0::CBMatrix)

copy with rounding

CBIndexmatrix(param0::CBSparsemat)

copy with rounding

CBLPGroundset()

calls clear() with the same parameters

CBLPGroundset(dim::Integer, lbyp::Union{<:CBMatrix,Nothing} = nothing, ubyp::Union{<:CBMatrix,Nothing} = nothing, Gp::Union{<:CBSparsemat,Nothing} = nothing, rhslbp::Union{<:CBMatrix,Nothing} = nothing, rhsubp::Union{<:CBMatrix,Nothing} = nothing, start_val::Union{<:CBMatrix,Nothing} = nothing, costs::Union{<:CBMatrix,Nothing} = nothing, offset::Real = 0., in_groundset_id::Integer = 0)

allows to specify the groundset in the constructor, zero is allowed everywhere

CBMatrix()

empty matrix

CBMatrix(param0::CBMatrix, d::Real = 1., atrans::Integer = 0)

copy constructor, this=dA

CBMatrix(param0::AbstractRange{<:Real}, param0_tol::Real = 1e-8)

generate a column vector holding the elements of this Realrange

CBMatrix(nr::Integer, nc::Integer)

• @brief generate a matrix of size nr x nc but WITHOUT initializing the memory

    If initializing the memory externally and CONICBUNDLE_DEBUG is defined, please use
    set_init() via matrix.set_init(true) in order to avoid warnings concerning improper
    initialization

CBMatrix(nr::Integer, nc::Integer, d::Real)

generate a matrix of size nr x nc initializing all elements to the value d

CBMatrix(nr::Integer, nc::Integer, dp::Union{<:AbstractVector{Cdouble},Nothing}, d::Real = 1.)

generate a matrix of size nr x nc initializing the elements from the (one dimensional) array dp with increment incr and scaled by d

CBMatrix(A::CBIndexmatrix, d::Real = 1.)

(this)=dA

CBMatrix(A::CBSparsemat, d::Real = 1.)

(this)=dA

CBMatrix(S::CBSymmatrix, d::Real = 1.)

(this)=dA

CBMatrix(param0::CBSparsesym, d::Real = 1.)

(this)=dA

CBMatrixCBSolver(print_level::Integer = 0)

default constructor allows to set output level options from start (see also set_out())

CBMicroseconds()

default constructor, value 0

CBMicroseconds(infty::Bool)

constructor for setting value to 0 or infinity

CBMicroseconds(m::CBMicroseconds)

copy constructor

CBMicroseconds(secs::Integer, msecs::Integer = 0)

specify directly seconds and microseconds (in [0,10^6], no range check!)

CBMicroseconds(hours::Integer, minutes::Integer, secs::Integer, micros::Integer)

convert hours, minutes, secs, micros to Microseconds (no range check!)

CBMinRes(pril::Integer = -1)

default constructor

CBMinorant(offset::Real, subg::CBDVector, primal::Union{<:CBPrimalData,Nothing} = nothing, offset_at_origin::Bool = false)

• @brief Minorant constructor for a dense subgradient specified via a DVector

  Suppose in the evaluation of your oracle at the current point \f$y\f$ you determine a subgradient \f$s\f$ for the subgradient inequality
  
  \f[ f(z)\ge f(y)+\langle s,z-y\rangle\quad\forall z\in\mathbf{R}^m, \f]
  
  then use \f$f(y)\f$ for @a offset and \f$s\f$ in the form of a DVector in @a subg and keep the default value @a offset_at_origin == false.
  
  If, on the other hand, your oracle implements a support function for some compact set \f$\mathcal{X}\subset\mathbf{R}^m\f$ like
  
  \f[ f(y) = \max_{x\in\mathcal{X}} x^\top y\f]
  
  then it is actually more efficient to return 0 for @a offset,
  a maximizing \f$x\f$ in @ subg and to put @a offset_at_origin = true.
  
  You may also pass over a PrimalData object in primal that will be then be
  owned and later deleted by the minorant and aggregated along with the minornat

CBMinorant(offset::Real, subg_val::CBDVector, subg_ind::CBIVector, primal::Union{<:CBPrimalData,Nothing} = nothing, offset_at_origin::Bool = false)

• @brief Minorant constructor for a sparse subgradient where the nonzero values are specified by DVector and the corresponding indices by an IVector

  Suppose in the evaluation of your oracle at the current point \f$y\f$ you determine a subgradient \f$s\f$ with few nonzeros for the subgradient inequality
  
  \f[ f(z)\ge f(y)+\langle s,z-y\rangle\quad\forall z\in\mathbf{R}^m, \f]
  
  then use \f$f(y)\f$ for @a offset and pass \f$s\f$ by giving the nonzeros in the DVector @a subg_val, the corresponding indices in a IVector of the same length in @a subg_ind and keep the default value @a offset_at_origin == false.
  
  If, on the other hand, your oracle implements a support function for some compact set \f$\mathcal{X}\subset\mathbf{R}^m\f$ like
  
  \f[ f(y) = \max_{x\in\mathcal{X}} x^\top y\f]
  
  then it is actually more efficient to return 0 for @a offset,
  a sparse maximizing \f$x\f$ in @a subg_val and @a subg_ind  and to put @a offset_at_origin = true.
  
  You may also pass over a PrimalData object in primal that will be then be
  owned and later deleted by the minorant and aggregated along with the minornat

CBMinorant(offset_at_origin::Bool = true, offset::Real = 0., n_elementes::Integer = 0, coeffs::Union{<:AbstractVector{Real},Nothing} = nothing, indices::Union{<:AbstractVector{Integer},Nothing} = nothing, scale_val::Real = 1., primal::Union{<:CBPrimalData,Nothing} = nothing)

• @brief default initializes a zero minorant, see full explanation otherwise; NOTE: if the offset supplied by the minorant refers to the evaluation point (i.e., if it is the function value at the point of evaluation), set @a offsetatorigin = false !

  In many applications, in particular for Lagrangian relaxation, the offset is more naturally given for the origin, and giving it this way also reduces computational cost a bit, so @a offsetatorigin = true is the suggested default. If, however, the minorant arises from a subgradient inequality by evaluation in the current point, you may as well give the function value as offset directly and set @a offsetatorigin=false;

  The data specifying the minorant may be set here or (part of) it may be entered/added later. The meaning of the other parameters is as follows.

  @a offset gives the constant value (if offsetatorigin = false then relative to the evaluation point)

  @a n_elements gives the number of elements specified by @a coeffs (and possibly indices), but if @a coeffs == NULL it just asks to reserve space for that many coefficients

  If @a coeffs is not NULL, it points to an array of doubles of size at least @a nelements. If @a indices == NULL then coeff[i] belongs to position i for i=0 to nelements-1, otherwise coeff[i] belongs to position indices[i]. All data is copied, the arrays are not modified, not used later and not deleted here.

  The entire input data (offset and coefficients) is multplied by @a scaleval to give the final minorant (scaleval is not memorized internally but executed immediately).

  If the minorant arises from @a PrimalData and the primal data should be aggregated along, it may be entered here or in the routine Minorant::set_primal(). The object pointed to is then owned by Minorant and will be deleted by Minorant on its destruction.

CBMinorant(mnrt::Union{<:CBMinorant,Nothing}, factor::Real = 1., with_primal::Bool = false)

they main purpose of this constructor is to allow easy cloning for derived classes

CBMinorantPointer()

declares the pointer empty

CBMinorantPointer(in_md::Union{<:CBMinorantUseData,Nothing})

initialize this to point to in_md

CBMinorantPointer(mp::CBMinorantPointer)

calls new_data

CBMinorantPointer(mp::CBMinorantPointer, factor::Real)

calls init(const MinorantPointer&,CHMatrixClasses::Real)

CBMinorantPointer(mnrt::Union{<:CBMinorant,Nothing}, modification_id::Integer, factor::Real = 1.)

calls init(Minorant*,CHMatrixClasses::Integer,CHMatrixClasses::Real)

CBMinorantUseData(mp::Union{<:CBMinorant,Nothing}, sval::Real, modif_id::Integer)

constructor for a new minorant with scaling @a sval and modification id @a modfi_id

CBMinorantUseData(mdp::Union{<:CBMinorantUseData,Nothing}, sval::Real)

constructor for a recursively containing further MinorantUseData with an additional scaling factor @a sval

enum CBMode

• cbm_root
• cbm_child
• cbm_inactive
• cbm_unavailable

enum CBModelUpdate

• cbmu_new_subgradient
• cbmu_descent_step
• cbmu_null_step

CBNNCBoxSupportFunction(lb::CBMatrix, ub::CBMatrix, incr::Integer = -1)

intialize with lower bounds vector lb and upper bounds vector ub (and output options), both must be column vectors of the same length and lb<=ub componentwise, length 0 results in objective value 0

CBNNCBoxSupportMinorantExtender(fun::Union{<:CBNNCBoxSupportFunction,Nothing})

the NNCBoxSupportFunction pointed to has to be valid for the livetime of this object

CBNNCBoxSupportModification(var_olddim::Integer = 0, incr::Integer = -1)

constructor, calls modification constructor

CBNNCData(fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function)

initializes BundleData, sets center_primal to NULL and calls clear()

CBNNCModel(fo::Union{<:CBMatrixFunctionOracle,Nothing}, fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function, cbinc::Integer = -1)

construct a model for the MatrixFunctionOracle pointed to by @a fo

CBNNCModelParameters(modelsize::Integer, bundlesize::Integer = 10, updaterule::Integer = 0, incr::Integer = -1)

constructor for size parameters

CBNNCModelParameters(bp::CBBundleParameters, incr::Integer = -1)

copy constructor for BundleParameters

CBNNCModelParameters(sms::CBNNCModelParameters)

copy constructor

CBPCG(pril::Integer = -1)

default constructor

CBPSCAffineFunction(C::CBSparseCoeffmatMatrix, opAt::CBSparseCoeffmatMatrix, generating_primal::Union{<:CBPSCPrimal,Nothing} = nothing, incr::Integer = -1)

• @brief initialize the PSCAffineFunction with its matrices and possible a generating_primal

  C and opAt define the constant (block-)offset and the linear (block-)matrix function as described in the general text of PSCAffineFunction

  generating_primal defines in what form primal matrices should be aggregated. If the argument is NULL then no primal aggregation will take place. The control over the generating primal is passed over to this. This will delete an existing generating primal whenever a new generating primal is set or upon destruction.

  The final two arguments allow to set the output, see CBout.

CBPSCAffineMinorantExtender(amf::Union{<:CBPSCAffineFunction,Nothing})

the PSCAffineFunction pointed to has to be valid for the livetime of this object

CBPSCAffineModification(var_olddim::Integer, block_olddim::CBIndexmatrix, incr::Integer = 0)

calls clear() with these parameters

CBPSCBundleParameters()

default constructor

CBPSCBundleParameters(bp::CBBundleParameters)

"copy" constructor

CBPSCData(fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function)

calls clear()

CBPSCModel(fo::Union{<:CBPSCOracle,Nothing}, fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function, cbinc::Integer = -1)

construct a model for the MatrixFunctionOracle pointed to by @a fo

CBPSCModelParameters(modelsize::Integer, bundlesize::Integer = 10, updaterule::Integer = 0, incr::Integer = -1)

constructor for size parameters

CBPSCModelParameters(bp::CBBundleParameters, incr::Integer = -1)

copy constructor for BundleParameters

CBPSCModelParameters(sms::CBPSCModelParameters)

copy constructor

CBPSCVariableMetricSelection(cbincr::Integer = -1)

default constructor

CBPrimalMatrix()

empty matrix

CBPrimalMatrix(nr::Integer, nc::Integer)

• @brief generate a matrix of size nr x nc but WITHOUT initializing the memory

    If initializing the memory externally and CONICBUNDLE_DEBUG is defined, please use
    set_init() via matrix.set_init(true) in order to avoid warnings concerning improper
    initialization

CBPrimalMatrix(r::Integer, c::Integer, d::Real)

generate a matrix of size nr x nc initializing all elements to the value d

CBPrimalMatrix(pm::CBPrimalMatrix)

copy constructor, *this=pm

CBPrimalMatrix(pm::CBMatrix)

copy constructor, *this=pm

CBPsqmr(pril::Integer = -1)

default constructor

CBQPConeModelBlock(cbinc::Integer = -1)

default constructor

CBQPDirectKKTSolver(in_factorize_ABC::Bool = false, cbinc::Integer = -1)

default constructor

CBQPIterativeKKTHASolver(insolver::Union{<:CBIterativeSolverObject,Nothing}, inprecond::Union{<:CBQPKKTPrecondObject,Nothing} = nothing, cbinc::Integer = -1)

default constructor

CBQPIterativeKKTHAeqSolver(insolver::Union{<:CBIterativeSolverObject,Nothing}, inprecond::Union{<:CBQPKKTPrecondObject,Nothing} = nothing, cbinc::Integer = -1)

default constructor

CBQPKKTSolverComparison(cbinc::Integer = -1)

default constructor

CBQPKKTSubspaceHPrecond(inmethod::Integer = 0, cbinc::Integer = -1)

default constructor

CBQPSolver(cbinc::Integer = -1)

default constructor

CBQPSolverParameters(incr::Integer = -1)

default constructor

CBQPSumModelBlock(cbincr::Integer = -1)

default constructor

CBSOCData(fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function)

calls clear()

CBSOCModel(fo::Union{<:CBSOCOracle,Nothing}, fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function, cbinc::Integer = -1)

construct a model for the MatrixFunctionOracle pointed to by @a fo

CBSOCModelParameters(modelsize::Integer, bundlesize::Integer = 10, updaterule::Integer = 0, incr::Integer = -1)

constructor for size parameters

CBSOCModelParameters(bp::CBBundleParameters, incr::Integer = -1)

copy constructor for BundleParameters

CBSOCModelParameters(sms::CBSOCModelParameters)

copy constructor

CBSOCSupportFunction(socdim::Integer, incr::Integer = -1)

initialize with dimension >= 1 (and output options)

CBSOCSupportMinorantExtender(fun::Union{<:CBSOCSupportFunction,Nothing})

the SOCSupportFunction pointed to has to be valid for the livetime of this object

CBSOCSupportModification(var_olddim::Integer = 0, incr::Integer = -1)

constructor, calls modification constructor

CBSparseCoeffmatMatrix(incr::Integer = -1)

set the output and call clear()

CBSparseCoeffmatMatrix(S::CBSparseCoeffmatMatrix, incr::Integer = -1)

set the output and call clear()

CBSparseCoeffmatMatrix(in_block_dim::CBIndexmatrix, in_col_dim::Integer, block_ind::Union{<:CBIndexmatrix,Nothing} = nothing, col_ind::Union{<:CBIndexmatrix,Nothing} = nothing, coeff_vec::Union{<:CBCoeffmatVector,Nothing} = nothing, incr::Integer = -1)

set the output and call init() for the given sparse information

CBSparsePSCPrimal(sps::CBSparsesym, factor::Real = 1.)

copy constructor from a CHMatrixClasses::Sparssym, only the support of this matrix will be used in all Gram operations

CBSparsePSCPrimal(pr::CBSparsePSCPrimal, factor::Real = 1.)

copy constructor, only the same support will be used in all Gram operations

CBSparsemat()

empty matrix

CBSparsemat(A::CBSparsemat, d::Real = 1.)

copy constructor, this=dA, abs(values)<tol are removed from the support

CBSparsemat(nr::Integer, nc::Integer)

initialize to zero-matrix of size nr*nc

CBSparsemat(nr::Integer, nc::Integer, nz::Integer, ini::Union{<:AbstractVector{Cint},Nothing}, inj::Union{<:AbstractVector{Cint},Nothing}, va::Union{<:AbstractVector{Cdouble},Nothing})

initialize to size nr*nc and nz nonzeros so that this(ini[i],inj[i])=val[i] for i=0,..,nz-1; multiple elements are summed up.

CBSparsemat(nr::Integer, nc::Integer, nz::Integer, ini::CBIndexmatrix, inj::CBIndexmatrix, va::CBMatrix)

initialize to size nr*nc and nz nonzeros so that this(ini(i),inj(i))=val(i) for i=0,..,nz-1; multiple elements are summed up.

CBSparsemat(A::CBMatrix, d::Real = 1.)

initialize to this=dA, abs(values)<tol are removed from the support

CBSparsemat(A::CBIndexmatrix, d::Real = 1.)

initialize to this=dA, zeros are removed from the support

CBSparsemat(A::CBSymmatrix, d::Real = 1.)

initialize to this=dA, abs(values)<tol are removed from the support

CBSparsemat(A::CBSparsesym, d::Real = 1.)

initialize to this=dA

CBSparsesym()

empty matrix

CBSparsesym(A::CBSparsesym, d::Real = 1.)

copy constructor, this=dA

CBSparsesym(nr::Integer)

initialize to zero-matrix of size nr*nr

CBSparsesym(nr::Integer, nz::Integer, ini::Union{<:AbstractVector{Cint},Nothing}, inj::Union{<:AbstractVector{Cint},Nothing}, va::Union{<:AbstractVector{Cdouble},Nothing})

initialize to size nr*nr and nz nonzeros so that this(ini[i],inj[i])=val[i] for i=0,..,nz-1; specify only one of (i,j) and (j,i), multiple elements are summed up.

CBSparsesym(nr::Integer, nz::Integer, ini::CBIndexmatrix, inj::CBIndexmatrix, va::CBMatrix)

initialize to size nr*nr and nz nonzeros so that this(ini(i),inj(i))=val[i] for i=0,..,nz-1; specify only one of (i,j) and (j,i), multiple elements are summed up.

CBSparsesym(param0::CBMatrix, d::Real = 1.)

initialize to this=d(A+transpose(A))/2., abs(values)<tol are removed from the support

CBSparsesym(param0::CBIndexmatrix, d::Real = 1.)

initialize to this=d(A+transpose(A))/2., zeros are removed from the support

CBSparsesym(param0::CBSymmatrix, d::Real = 1.)

initialize to this=Ad, abs(values)<tol are removed from the support

CBSparsesym(param0::CBSparsemat, d::Real = 1.)

initialize to this=d(A+transpose(A))/2.

CBSumBundle(sb::CBSumBundle)

copy constructor

CBSumBundleParameters(modelsize::Integer, bundlesize::Integer = 10, updaterule::Integer = 0, incr::Integer = -1)

constructor for customized parameters

CBSumBundleParameters(sbp::CBSumBundleParameters)

copy constructor

CBSumModel()

constructor

CBSymmatrix()

empty matrix

CBSymmatrix(A::CBSymmatrix, d::Real = 1.)

copy constructor, this=dA

CBSymmatrix(nr::Integer)

• @brief generate a matrix of size nr x nr but WITHOUT initializing the memory

    If initializing the memory externally and CONICBUNDLE_DEBUG is defined, please use
    set_init() via matrix.set_init(true) in order to avoid warnings concerning improper
    initialization

CBSymmatrix(nr::Integer, d::Real)

generate a matrix of size nr x nr initializing all elements to the value d

CBSymmatrix(nr::Integer, dp::Union{<:AbstractVector{Cdouble},Nothing})

generate a matrix of size nr x nr initializing the elements from the (one dimensional) array dp, which must have the elements arranged consecutively in internal order

CBSymmatrix(param0::CBMatrix, d::Real = 1.)

(this)=d(A+transpose(A))/2.

CBSymmatrix(param0::CBIndexmatrix, d::Real = 1.)

(this)=d(A+transpose(A))/2.

CBSymmatrix(A::CBSparsesym, d::Real = 1.)

(this)=dA

CBUQPConeModelBlock(cbinc::Integer = -1)

default constructor

CBUQPSolver(cbinc::Integer = -1)

default constructor

CBUQPSumModelBlock(incr::Integer = -1)

default constructor

CBUnconstrainedGroundset(indim::Integer = 0, start_val::Union{<:CBMatrix,Nothing} = nothing, costs::Union{<:CBMatrix,Nothing} = nothing, offset::Real = 0., in_groundset_id::Integer = 0)

calls clear() with the same parameters

CBVariableMetricSVDSelection(cbincr::Integer = -1)

default constructor

CBVariableMetricSVDSelection(in_n_latest_minorants::Integer, in_selection_method::Integer, in_oldfactor::Real = 0., cbincr::Integer = -1)

constructor for specifying values for nlatestminorants and selection_method

cb_Aasen_Lsolve(self::CBSymmatrix, x::CBMatrix)

computes, after Aasen_factor into LTL^T was executed, the solution to Lx=rhs; rhs is overwritten by the solution; always returns 0;

cb_Aasen_Ltsolve(self::CBSymmatrix, x::CBMatrix)

computes, after Aasen_factor into LTL^T was executed, the solution to L^Tx=rhs; rhs is overwritten by the solution; always returns 0;

cb_Aasen_factor!(self::CBSymmatrix, piv::CBIndexmatrix)

computes Aasen factorization LTL^T with pivoting, where L is unit lower triangular with first colum e_1 and T is tridiagonal; (this) is overwritten by the factorization, with column i of L being stored in column i-1 of (this); always returns 0;

cb_Aasen_solve(self::CBSymmatrix, x::CBMatrix, piv::CBIndexmatrix)

computes, after Aasenfactor into LTL^T was executed, the solution to (*oldthis)x=rhs; rhs is overwritten by the solution; if the solution fails due to division by zero (=system not solvable) the return value is -(rowindex+1) where this occured in the backsolve

cb_Aasen_tridiagsolve(self::CBSymmatrix, x::CBMatrix)

computes, after Aasen_factor into LTL^T was executed, the solution to Tx=rhs; rhs is overwritten by the solution;if the solution fails due to division by zero (=system not solvable) the return value is -(rowindex+1) where this occured in the backsolve

cb_B_times!(self::CBQPConeModelBlock, A::CBMatrix, C::CBMatrix, alpha::Real, beta::Real, Btrans::Integer, Atrans::Integer, startindex_model::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

C=betaC+alphaB*A where B and A may be transposed; carry out the model part of this beginning at startindex_model and beta for the part, that is added to (the calling routine has to make sure beta is not executed repeatedly if the same part is affected by other models as well)

cb_B_times!(self::CBQPSumModelBlock, A::CBMatrix, C::CBMatrix, alpha::Real, beta::Real, Btrans::Integer, Atrans::Integer, startindex_model::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

C=betaC+alphaB*A where B and A may be transposed; carry out the model part of this beginning at startindex_model and beta for the part, that is added to (the calling routine has to make sure beta is not executed repeatedly if the same part is affected by other models as well)

cb_Chol_Lmult(self::CBSymmatrix, rhs::CBMatrix)

computes, after Chol_factor into LL^T was executed succesfully, L*rhs, overwriting rhs by the result; always returns 0;

cb_Chol_Lsolve(self::CBSymmatrix, rhs::CBMatrix)

computes, after Chol_factor into LL^T was executed succesfully, the solution to Lx=rhs; rhs is overwritten by the solution; always returns 0; NOTE: there is NO check against division by zero

cb_Chol_Ltmult(self::CBSymmatrix, rhs::CBMatrix)

computes, after Chol_factor into LL^T was executed succesfully, L^Trhs, overwriting rhs by the result; always returns 0;

cb_Chol_Ltsolve(self::CBSymmatrix, rhs::CBMatrix)

computes, after Chol_factor into LL^T was executed succesfully, the solution to L^Tx=rhs; rhs is overwritten by the solution; always returns 0; NOTE: there is NO check against division by zero

cb_Chol_factor!(self::CBSymmatrix, tol::Real = 1e-10)

computes the Cholesky factorization, for positive definite matrices only, (*this) is overwritten by the factorization; there is no pivoting; returns 1 if diagonal elements go below tol

cb_Chol_factor!(self::CBSymmatrix, piv::CBIndexmatrix, tol::Real = 1e-10)

computes the Cholesky factorization with pivoting, for positive semidefinite matrices only, (*this) is overwritten by the factorization; on termination piv.dim() is the number of positive pivots>=tol; returns 1 if negative diagonal element is encountered during computations, 0 otherwise.

cb_Chol_inverse(self::CBSymmatrix, S::CBSymmatrix)

computes, after Cholfactor was executed succesfully, the inverse to (*oldthis) and stores it in S (numerically not too wise); always returns 0; NOTE: there is NO check against division by zero

cb_Chol_inverse(self::CBSymmatrix, S::CBSymmatrix, piv::CBIndexmatrix)

computes, after Cholfactor(Indexmatrix&,Real) with pivoting was executed succesfully, the inverse to (*oldthis) and stores it in S (the pivoting permutation is undone in S); NOTE: there is NO check against division by zero

cb_Chol_scaleLi(self::CBSymmatrix, S::CBSymmatrix)

computes, after Chol_factor into LL^T was executed succesfully, L^{-1}SL^{-T} overwriting S

cb_Chol_scaleLt(self::CBSymmatrix, S::CBSymmatrix)

computes, after Chol_factor into LL^T was executed succesfully, L^TSL overwriting S

cb_Chol_solve(self::CBSymmatrix, x::CBMatrix)

computes, after Cholfactor was executed succesfully, the solution to (*oldthis)x=rhs; rhs is overwritten by the solution; always returns 0; NOTE: there is NO check against division by zero

cb_Chol_solve(self::CBSymmatrix, x::CBMatrix, piv::CBIndexmatrix)

computes, after Cholfactor(Indexmatrix&,Real) with pivoting was executed succesfully, the solution to (*oldthis)*x=rhs(piv); rhs is overwritten by the solution arranged in original unpermuted order; always returns 0; NOTE: there is NO check against division by zero

cb_Diag(A::CBMatrix)

returns a symmetric diagonal matrix S of order A.dim() with vec(A) on the diagonal, i.e., S(i,i)=A(i) for all i and S(i,j)=0 for i!=j

cb_Gram_ip(self::CBSparseCoeffmatMatrix, ipvec::CBMatrix, P::CBMatrix, Lam::Union{<:CBMatrix,Nothing} = nothing, ind::Union{<:CBIndexmatrix,Nothing} = nothing)

computes the inner products of (selected) columns (which represent block diagonal symmetric matrices) with the Gram matrix PP^T (or, if Lam is given, PDiag(Lam)P^T) into the column vector ipvec(j)=ip(PP^T,A.column((*ind)(j)}) (j=0,...,ind->dim()-1); if ind==NULL, use all columns

cb_Gram_ip(self::CBSparseCoeffmatMatrix, P::CBMatrix, j::Integer)

computes the inner product of the block diagonal symmetric matrix stored in colummn j with the Gram matrix PP^T into ipval=ip(PP^T,A.column(j))

cb_ItSys_mult!(self::CBQPIterativeKKTHAeqSolver, in_vec::CBMatrix, out_vec::CBMatrix)

returns outvec=(system matrix)*invec

cb_ItSys_mult!(self::CBQPIterativeKKTHASolver, in_vec::CBMatrix, out_vec::CBMatrix)

returns outvec=(system matrix)*invec

cb_LDLfactor!(self::CBSymmatrix, tol::Real = 1e-10)

computes LDLfactorization (implemented only for positive definite matrices so far, no pivoting), (*this) is overwritten by the factorization; returns 1 if diagonal elements go below tol

cb_LDLinverse(self::CBSymmatrix, S::CBSymmatrix)

computes, after LDLfactor was executed succesfully, the inverse to (*old_this) and stores it in S (numerically not too wise); always returns 0; NOTE: there is NO check against division by zero

cb_LDLsolve(self::CBSymmatrix, x::CBMatrix)

computes, after LDLfactor was executed succesfully, the solution to (*old_this)x=rhs; rhs is overwritten by the solution; always returns 0; NOTE: there is NO check against division by zero

cb_QPallow_UQPSolver!(self::CBQPSolverParameters)

set to true/false if switching to the unconstrained solver is allowed or not

cb_QPapply_modification!(self::CBQPSolver, mdf::CBGroundsetModification)

groundset changes are communicated to the solver here

cb_QPapply_modification!(self::CBUQPSolver, param0::CBGroundsetModification)

no modifications need to be carried out here as there is no data to be modified, so any modification succeeds

cb_QPclear!(self::CBQPSolver)

(re)initialize to empty

cb_QPclear!(self::CBUQPSolver)

calls clear(), i.e. reinitialize completely

cb_QPconstrained(self::CBQPSolver)

returns false if the feasible set is the entire space (unconstrained optimization), true otherwise.

cb_QPconstrained(self::CBUQPSolver)

it is always unconstrained

cb_QPensure_feasibility!(self::CBQPSolver, y::CBMatrix, ychanged::Bool, inHp::Union{<:CBQPSolverProxObject,Nothing}, relprec::Real = 1e-10)

makes y feasible if not so, see Groundset::ensure_feasibility()

cb_QPensure_feasibility!(self::CBUQPSolver, param0::CBMatrix, ychanged::Bool, param2::Union{<:CBQPSolverProxObject,Nothing}, param3::Real = 1e-10)

for the unconstrained solver any point is feasible, because it cannot even check the dimension of the design space, so any y is left unchanged

cb_QPget_KKTsolver!(self::CBQPSolverParameters)

get this variable value

cb_QPget_blockA_norm!(self::CBQPKKTSolverComparison)

for judging violation this returns (an estimate of) the norm of the A-row in the latest system

cb_QPget_blockH_norm!(self::CBQPKKTSolverComparison)

for judging violation this returns (an estimate of) the norm of the H-row in the latest system

cb_QPget_dual_infeasibility_eps(self::CBQPSolverParameters)

get this variable value

cb_QPget_lower_bound(self::CBQPSolverParameters)

get this variable value

cb_QPget_lower_bound!(self::CBQPSolver)

returns the current lower bound on the optimal value (if feasibility is good enough)

cb_QPget_lower_bound!(self::CBUQPSolver)

return the lower bound on the objective value of the bundle subproblem

cb_QPget_lower_bound_gap_eps(self::CBQPSolverParameters)

get this variable value

cb_QPget_maxiter(self::CBQPSolverParameters)

get this variable value

cb_QPget_min_objective_relprec(self::CBQPSolverParameters)

get this variable value

cb_QPget_nbh_lb(self::CBQPSolverParameters)

get this variable value

cb_QPget_nbh_ub(self::CBQPSolverParameters)

get this variable value

cb_QPget_objective_gap_eps(self::CBQPSolverParameters)

get this variable value

cb_QPget_primal_infeasibility_eps(self::CBQPSolverParameters)

get this variable value

cb_QPget_solution!(self::CBQPSolver, new_point::CBMatrix, gsaggr_gradient::CBMatrix)

retrieve the solution produced (see \ref InternalQPSolverInterface)

cb_QPget_solution!(self::CBUQPSolver, new_point::CBMatrix, gsaggr_gradient::CBMatrix)

the unconstrained solver can only provide this information if the references to the input data of QPsolve() and QPudate() are still available and unchanged, otherwise the behavior is undefined and will hopefully return 1 if not valid

cb_QPget_system_size!(self::CBQPIterativeKKTHAeqSolver)

for evaluation purposes with iterative solvers, return the size of the system matrix

cb_QPget_system_size!(self::CBQPIterativeKKTHASolver)

for evaluation purposes with iterative solvers, return the size of the system matrix

cb_QPget_upper_bound(self::CBQPSolverParameters)

get this variable value

cb_QPget_upper_bound_gap_eps(self::CBQPSolverParameters)

get this variable value

cb_QPget_use_neighborhood(self::CBQPSolverParameters)

get this variable value

cb_QPget_use_predictor_corrector(self::CBQPSolverParameters)

get this variable value

cb_QPget_use_socqp(self::CBQPSolverParameters)

get this variable value

cb_QPinit_KKTdata!(self::CBQPDirectKKTSolver, Hp::Union{<:CBQPSolverProxObject,Nothing}, model::Union{<:CBQPModelBlockObject,Nothing}, A::Union{<:CBSparsemat,Nothing}, eq_indices::Union{<:CBIndexmatrix,Nothing})

returns 1 if this class is not applicable in the current data situation, otherwise it stores the data pointers and these need to stay valid throught the use of the other routines but are not deleted here

cb_QPinit_KKTdata!(self::CBQPIterativeKKTHAeqSolver, Hp::Union{<:CBQPSolverProxObject,Nothing}, model::Union{<:CBQPModelBlockObject,Nothing}, A::Union{<:CBSparsemat,Nothing}, eq_indices::Union{<:CBIndexmatrix,Nothing})

returns 1 if this class is not applicable in the current data situation, otherwise it stores the data pointers and these need to stay valid throught the use of the other routines but are not deleted here

cb_QPinit_KKTdata!(self::CBQPKKTSolverComparison, Hp::Union{<:CBQPSolverProxObject,Nothing}, model::Union{<:CBQPModelBlockObject,Nothing}, A::Union{<:CBSparsemat,Nothing}, eq_indices::Union{<:CBIndexmatrix,Nothing})

returns 1 if this class is not applicable in the current data situation, otherwise it stores the data pointers and these need to stay valid throught the use of the other routines but are not deleted here

cb_QPinit_KKTsystem!(self::CBQPDirectKKTSolver, KKTdiagx::CBMatrix, KKTdiagy::CBMatrix, Hfactor::Real, prec::Real, params::Union{<:CBQPSolverParameters,Nothing})

set up the primal dual KKT system for being solved for predictor and corrector rhs in QPsolve_KKTsystem

cb_QPinit_KKTsystem!(self::CBQPKKTSolverComparison, KKTdiagx::CBMatrix, KKTdiagy::CBMatrix, Hfactor::Real, prec::Real, params::Union{<:CBQPSolverParameters,Nothing})

set up the primal dual KKT system for being solved for predictor and corrector rhs in QPsolve_KKTsystem

cb_QPis_feasible!(self::CBQPSolver, y::CBMatrix, relprec::Real = 1e-10)

check feasiblity of y for the current groundset constraints

cb_QPis_feasible!(self::CBUQPSolver, param0::CBMatrix, param1::Real = 1e-10)

for the unconstrained solver any point is feasible, because it cannot even check the dimension of the design space

cb_QPprefer_UQPSolver(self::CBQPSolver, param0::Union{<:CBQPSolverProxObject,Nothing})

returns true if, for the current constraints and the requested ProxObject, it might be better to use the internal unconstrained QP solver (which can deal with box constraints by a work-around)

cb_QPprefer_UQPSolver(self::CBUQPSolver, param0::Union{<:CBQPSolverProxObject,Nothing})

as this IS the internal UQPSolver, the answer doesn't matter, but the solver would certainly say yes

cb_QPprint_statistics!(self::CBQPSolver, param1::Integer = 0)

currently it does nothing

cb_QPprint_statistics!(self::CBUQPSolver, param1::Integer = 0)

outputs some statistical data about solver performance

cb_QPresolve!(self::CBQPSolver, lower_bound::Real, upper_bound::Real, relprec::Real)

resolve the bundle subproblem (usually because of modified penalty parameters) so that precision requirements are met (see \ref InternalQPSolverInterface)

cb_QPresolve!(self::CBUQPSolver, lower_bound::Real, upper_bound::Real, relprec::Real)

see QPSolverObject::QPresolve() and \ref UnconstrainedQPSolver

cb_QPset_KKTsolver!(self::CBQPSolverParameters, in_KKTsolver::Union{<:CBQPKKTSolverObject,Nothing})

delete previous solver and replace by the new one (should not be zero when calling the solver)

cb_QPset_allow_UQPSolver!(self::CBQPSolverParameters, allow::Bool)

set to true/false if switching to the unconstrained solver is allowed or not

cb_QPset_dual_infeasibility_eps!(self::CBQPSolverParameters, eps::Real)

set this variable value

cb_QPset_lower_and_upper_bounds!(self::CBQPSolverParameters, lb::Real, ub::Real)

set this variable value

cb_QPset_lower_bound_gap_eps!(self::CBQPSolverParameters, eps::Real)

set this variable value

cb_QPset_maxiter!(self::CBQPSolverParameters, mi::Integer)

set this variable value

cb_QPset_min_objective_relprec!(self::CBQPSolverParameters, eps::Real)

set this variable value

cb_QPset_nbh_bounds!(self::CBQPSolverParameters, nbhlb::Real, nbhub::Real)

set the upper bound on the neighborhood that should be ensured in curve searches; ensures eps_Real<=nbhlb<=nbhub (nbhub should be < 1. and <=.35 is safe)

cb_QPset_objective_gap_eps!(self::CBQPSolverParameters, eps::Real)

set this variable value

cb_QPset_parameters!(self::CBQPSolver, params::Union{<:CBQPSolverParametersObject,Nothing})

check whether the parameters are QPSolverParameters and set them if so

cb_QPset_parameters!(self::CBUQPSolver, param0::Union{<:CBQPSolverParametersObject,Nothing})

does nothing here

cb_QPset_primal_infeasibility_eps!(self::CBQPSolverParameters, eps::Real)

set this variable value

cb_QPset_upper_bound_gap_eps!(self::CBQPSolverParameters, eps::Real)

set this variable value

cb_QPset_use_neighborhood!(self::CBQPSolverParameters, nbh::Bool)

if set to true (default: false), the lines search is carried out with respect to the neighborhood polynomial ensuring the afte this step the point is again inside the neighborhood of the central path

cb_QPset_use_predictor_corrector!(self::CBQPSolverParameters, upc::Bool)

if set to true (=default), a predictor corrector approach is used for solving the KKT system (solve for barrier parameter mu=0, guess mu, solve again for this mu including some bilinear perturbation) otherwise the barrier parameter is set apriori and the step computed in one solve

cb_QPset_use_socqp!(self::CBQPSolverParameters, s::Bool)

if set to true (default: false), the quadratic term is modelled via a second order cone approach

cb_QPsolve!(self::CBQPSolver, center_y::CBMatrix, lower_bound::Real, upper_bound::Real, relprec::Real, Hp::Union{<:CBQPSolverProxObject,Nothing}, gs_aggr::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing})

solve the current bundle subproblem so that precision requirements are met (see \ref InternalQPSolverInterface)

cb_QPsolve!(self::CBUQPSolver, center_y::CBMatrix, lower_bound::Real, upper_bound::Real, relprec::Real, Hp::Union{<:CBQPSolverProxObject,Nothing}, gs_aggr::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing})

see QPSolverObject::QPsolve() and \ref UnconstrainedQPSolver

cb_QPsolve_KKTsystem!(self::CBQPDirectKKTSolver, solx::CBMatrix, soly::CBMatrix, primalrhs::CBMatrix, dualrhs::CBMatrix, rhsmu::Real, rhscorr::Real, prec::Real, params::Union{<:CBQPSolverParameters,Nothing})

solve the KKTsystem to precision prec for the given right hand sides that have been computed for the value rhsmu of the barrier parameter and in which a rhscorr fraction (out of [0,1] of the corrector term have been included; in iterative solvers solx and soly may be used as starting points

cb_QPsolve_KKTsystem!(self::CBQPIterativeKKTHAeqSolver, solx::CBMatrix, soly::CBMatrix, primalrhs::CBMatrix, dualrhs::CBMatrix, rhsmu::Real, rhscorr::Real, prec::Real, params::Union{<:CBQPSolverParameters,Nothing})

solve the KKTsystem to precision prec for the given right hand sides that have been computed for the value rhsmu of the barrier parameter and in which a rhscorr fraction (out of [0,1] of the corrector term have been included; in iterative solvers solx and soly may be used as starting points

cb_QPsolve_KKTsystem!(self::CBQPIterativeKKTHASolver, solx::CBMatrix, soly::CBMatrix, primalrhs::CBMatrix, dualrhs::CBMatrix, rhsmu::Real, rhscorr::Real, prec::Real, params::Union{<:CBQPSolverParameters,Nothing})

solve the KKTsystem to precision prec for the given right hand sides that have been computed for the value rhsmu of the barrier parameter and in which a rhscorr fraction (out of [0,1] of the corrector term have been included; in iterative solvers solx and soly may be used as starting points

cb_QPsolve_KKTsystem!(self::CBQPKKTSolverComparison, solx::CBMatrix, soly::CBMatrix, primalrhs::CBMatrix, dualrhs::CBMatrix, rhsmu::Real, rhscorr::Real, prec::Real, params::Union{<:CBQPSolverParameters,Nothing})

solve the KKTsystem to precision prec for the given right hand sides that have been computed for the value rhsmu of the barrier parameter and in which a rhscorr fraction (out of [0,1] of the corrector term have been included; in iterative solvers solx and soly may be used as starting points

cb_QPstart_modification!(self::CBQPSolver)

return a new modification object on the heap that is initialized for modification of *this

cb_QPstart_modification!(self::CBUQPSolver)

returns 0 because no modifications are applicable

cb_QPsupports_updates!(self::CBQPSolver)

• @brief return true iff the code supports QPupdate(), i.e., it supports external updates of the groundset aggregate in order to model constraints not included explicitly in the QP's model

cb_QPsupports_updates!(self::CBUQPSolver)

• @brief return true iff the code supports QPupdate(), i.e., it supports external updates of the groundset aggregate in order to model constraints not included explicitly in the QP's model

cb_QPsupports_yfixing!(self::CBQPSolver)

yfixing is currently not supported, this returns false.

cb_QPsupports_yfixing!(self::CBUQPSolver)

no difficulty if the BundleProxObject does it

cb_QPupdate!(self::CBQPSolver, center_y::CBMatrix, lower_bound::Real, upper_bound::Real, relprec::Real, Hp::Union{<:CBQPSolverProxObject,Nothing}, gs_aggr::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing}, delta_gs_aggr::CBMinorantPointer, delta_index::CBIndexmatrix)

solve the bundle subproblem for updated box multipliers so that precision requirements are met (see \ref InternalQPSolverInterface). This routine is typically not called for this solver, because box constraints are included explicitly.

cb_QPupdate!(self::CBUQPSolver, center_y::CBMatrix, lower_bound::Real, upper_bound::Real, relprec::Real, Hp::Union{<:CBQPSolverProxObject,Nothing}, gs_aggr::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing}, delta_gs_subg::CBMinorantPointer, delta_index::CBIndexmatrix)

see QPSolverObject::QPupdate() and \ref UnconstrainedQPSolver

cb_QR_concat_right!(self::CBMatrix, A::CBMatrix, piv::CBIndexmatrix, r::Integer, tol::Real = 1e-10)

• extend the current Householder QR-factorization stored in this by appending and factorizing the columns of A yielding a new QR_factorization

    @param[in] A contains the addtionial columns to be factorized
  
    @param[in,out] piv contains on input, the permution vector returned by QR_factor
        with pivoting, and on output the new entire permutation
  
    @param[in] r gives the initial rank of *this as returned by QR_factor with pviaton
  
    @param[in] tol gives the tolerance for regarding a vector as having norm zero
  
    @return the rank of the new QR-facotrization

cb_QR_factor(self::CBMatrix, Q::CBMatrix, R::CBMatrix, tol::Real)

computes a Householder QR_factorization computing matrices Q and R explicitly and leaving (*this) unchanged; it always returns 0

cb_QR_factor(self::CBMatrix, Q::CBMatrix, R::CBMatrix, piv::CBIndexmatrix, tol::Real)

computes a Householder QR_factorization with pivoting computing matrices Q and R explicitly and leaving (*this) unchanged; the pivoting permutation is stored in piv; returns the rank

cb_QR_factor!(self::CBMatrix, tol::Real = 1e-10)

computes a Householder QR_factorization overwriting (*this); returns 0 on success, otherwise column index +1 if the norm of the column is below tol when reaching it.

cb_QR_factor!(self::CBMatrix, Q::CBMatrix, tol::Real = 1e-10)

computes a Householder QR_factorization computing the Q matrix explicitly and setting (*this)=R; it always returns 0

cb_QR_factor!(self::CBMatrix, piv::CBIndexmatrix, tol::Real = 1e-10)

computes a Householder QR_factorization with pivoting and overwriting (*this); the pivoting permutation is stored in piv; returns the rank

cb_QR_factor!(self::CBMatrix, Q::CBMatrix, piv::CBIndexmatrix, tol::Real = 1e-10)

Computes a Householder QR_factorization with pivoting computing the Q matrix explicitly and setting (*this)=R; the pivoting permutation is stored in piv; returns the rank

cb_QR_factor_relpiv!(self::CBMatrix, piv::CBIndexmatrix, tol::Real = 1e-10)

computes a Householder QR_factorization with pivoting on those with tolerable norm and tolerable reduction in norm and overwriting (*this); the pivoting permutation is stored in piv; returns the rank

cb_QR_solve!(self::CBMatrix, rhs::CBMatrix, tol::Real = 1e-10)

• @brief solves (this)x=rhs by factorizing and overwriting (this); rhs is overwritten with the solution. Returns 0 on success, otherwise i+1 if in the backsolve abs(this)(i,i)<tol and the reduced row of rhs is nonzero.

    To avoid overwriting (*this), use the appropriate version
    of #QR_factor and #triu_solve.

cb_Q_times(self::CBMatrix, A::CBMatrix, r::Integer)

computes A=QA, assuming a housholder Q is coded in the first r columns of the lower triangle of (this); it always returns 0

cb_Qt_times(self::CBMatrix, A::CBMatrix, r::Integer)

computes A=transpose(Q)A, assuming a housholder Q is coded in the first r columns of the lower triangle of (this); it always returns 0

cb_abs(A::CBMatrix)

returns a matrix with elements (i,j)=abs((*this)(i,j)) for all i,j

cb_abs(A::CBSparsemat)

returns a Sparsmat with elements abs((*this)(i,j)) for all i,j

cb_abs(A::CBSymmatrix)

returns a Symmatrix with elements abs(A(i,j))

cb_abs(A::CBSparsesym)

returns a Sparsesym with elements abs((*this)(i,j)) for all i,j

cb_abs!(self::CBMatrix)

sets (this)(i,j)=abs((this)(i,j)) for all i,j and returns *this

cb_abs!(self::CBIndexmatrix)

using ::abs assign (this)(i,j)=abs((this)(i,j)) for all i,j

cb_active(self::CBSumBundle)

returns true if one of its parts is not inactive

cb_add_BCSchur_diagonal!(self::CBQPConeModelBlock, diagonal::CBMatrix, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

• @brief add the diagonal of the Schur complemented blocks belonging to bundle and local constraints (used for diagonal preconditioning)

cb_add_BCSchur_diagonal!(self::CBQPSumModelBlock, diagonal::CBMatrix, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

• @brief add the diagonal of the Schur complemented blocks belonging to bundle and local constraints (used for diagonal preconditioning)

cb_add_BDBt!(self::CBQPConeModelBlock, diagvec::CBMatrix, bigS::CBSymmatrix, minus::Bool, startindex::Integer, Bt::CBMatrix, startindex_model::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

add the main diagonal block tranpose(projection)diagvecprojection to bigS starting at startindex

cb_add_BDBt!(self::CBQPSumModelBlock, diagvec::CBMatrix, bigS::CBSymmatrix, minus::Bool, startindex::Integer, Bt::CBMatrix, startindex_model::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

add the main diagonal block tranpose(projection)diagvecprojection to bigS starting at startindex

cb_add_Bs(self::CBUQPConeModelBlock, qp_vec::CBMatrix)

add the local product of matrices B and s in the positions corresponding to qpyrange (rows) and return qpvec; returns 0 on success, 1 on failure

cb_add_Bs(self::CBUQPSumModelBlock, qp_vec::CBMatrix)

do this for all subblocks

cb_add_BtinvsysB!(self::CBQPConeModelBlock, globalsys::CBSymmatrix, bundle::CBMinorantBundle, startindex_bundle::Integer)

add the "scaled" minorant outer products to globalsys, where the correct minorants start at the given index

cb_add_BtinvsysB!(self::CBQPSumModelBlock, globalsys::CBSymmatrix, bundle::CBMinorantBundle, startindex_bundle::Integer)

add the "scaled" minorant outer products to globalsys, where the correct minroants start at the given index

cb_add_H(self::CBBundleDenseTrustRegionProx, big_sym::CBSymmatrix, start_index::Integer = 0)

add H to the dense symmetric matrix as a principal submatrix starting at position start_index

cb_add_H(self::CBBundleDiagonalTrustRegionProx, big_sym::CBSymmatrix, start_index::Integer = 0)

add H to the dense symmetric matrix as a principal submatrix starting at position start_index

cb_add_H(self::CBBundleDLRTrustRegionProx, big_sym::CBSymmatrix, start_index::Integer = 0)

add H to the dense symmetric matrix as a principal submatrix starting at position start_index

cb_add_H(self::CBBundleIdProx, big_sym::CBSymmatrix, start_index::Integer = 0)

add H to the dense symmetric matrix as a principal submatrix starting at position start_index

cb_add_H(self::CBBundleLowRankTrustRegionProx, big_sym::CBSymmatrix, start_index::Integer = 0)

add H to the dense symmetric matrix as a principal submatrix starting at position start_index

cb_add_Hx(self::CBBundleDenseTrustRegionProx, x::CBMatrix, outplusHx::CBMatrix, alpha::Real = 1.)

adds \f$alpha*Hx\f$ to outplusHx and returns this

cb_add_Hx(self::CBBundleDiagonalTrustRegionProx, x::CBMatrix, outplusHx::CBMatrix, alpha::Real = 1.)

adds \f$alpha*Hx\f$ to outplusHx and returns this

cb_add_Hx(self::CBBundleDLRTrustRegionProx, x::CBMatrix, outplusHx::CBMatrix, alpha::Real = 1.)

adds \f$alpha*Hx\f$ to outplusHx and returns this

cb_add_Hx(self::CBBundleIdProx, x::CBMatrix, outplusHx::CBMatrix, alpha::Real = 1.)

adds \f$alpha*Hx\f$ to outplusHx and returns this

cb_add_Hx(self::CBBundleLowRankTrustRegionProx, x::CBMatrix, outplusHx::CBMatrix, alpha::Real = 1.)

adds \f$alpha*Hx\f$ to outplusHx and returns this

cb_add_Schur_mult!(self::CBQPConeModelBlock, in_vec::CBMatrix, out_vec::CBMatrix, in_cvec::Union{<:CBMatrix,Nothing}, out_cvec::Union{<:CBMatrix,Nothing}, startindex_constraints::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

multiply invec with the local contribution to the global main block and add it to outvec; the other local multiplications are carried out externally with the information provide in prepareSchurprecond and are not done here.

cb_add_Schur_mult!(self::CBQPSumModelBlock, in_vec::CBMatrix, out_vec::CBMatrix, in_cvec::Union{<:CBMatrix,Nothing}, out_cvec::Union{<:CBMatrix,Nothing}, startindex_constraints::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

multiply invec with the local contribution to the global main block and add it to outvec; the other local multiplications are carried out externally with the information provide in prepareSchurprecond and are not done here.

cb_add_Schur_rhs!(self::CBQPConeModelBlock, glob_rhs::CBMatrix, local_rhs::Union{<:CBMatrix,Nothing}, rhsmu::Real, rhscorr::Real, startindex_constraints::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

add the contributions to globrhs of the Schur complemented model block, and return localrhs of the non complemented constraint block in the rows/columns/diagonal block starting at startindex_constraints

cb_add_Schur_rhs!(self::CBQPSumModelBlock, glob_rhs::CBMatrix, local_rhs::Union{<:CBMatrix,Nothing}, rhsmu::Real, rhscorr::Real, startindex_constraints::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

add the contributions to globrhs of the Schur complemented model block, and return localrhs of the non complemented constraint block in the rows/columns/diagonal block starting at startindex_constraints

cb_add_append_blocks!(self::CBPSCAffineModification, append_dim::CBIndexmatrix, append_offsets::Union{<:CBSparseCoeffmatMatrix,Nothing}, append_blocks::Union{<:CBSparseCoeffmatMatrix,Nothing})

• @brief append information on new rows at the respective ends

   @param append_dim
          the dimension gives the number of (diagonal) blocks and each
    entry the order of the block to be appended
  
   @param append_blocks
          if NULL, append zero matrics, otherwise it must point
          to a sparse matrix of size @a append_dim times new_vardim()
          that is to be appended to the constraint matrix below.
  
   @param append_offsets
          if NULL, append zero matrices, otherwise it must point to
    a column vector of size @a append_dim that is to be appended
          to the vector of offsets

   @return number of errors; if errors occured, none of the new changes are performed

cb_add_append_rows!(self::CBAFTModification, append_dim::Integer, append_rows::Union{<:CBSparsemat,Nothing}, append_rhs::Union{<:CBMatrix,Nothing})

append @a appenddim new rows as in appendrows (if NULL, use default value) with affine offset appendrhs (if NULL use default value 0.), calls Modification::addappend_rows

cb_add_append_variables!(self::CBAFTModification, append_dim::Integer)

append append_dim further variables at the end of the argument vector (without specifying their effect, they may e.g. be ignored by the function)

cb_add_append_variables!(self::CBGroundsetModification, append_dim::Integer)

append append_dim further variables at the end of the argument vector (without specifying their effect, they may e.g. be ignored by the function)

cb_add_append_variables!(self::CBNNCBoxSupportModification, append_dim::Integer)

append append_dim further variables at the end of the argument vector (without effect on the box function, i.e., lower and upper bounds are set to 0)

cb_add_append_variables!(self::CBPSCAffineModification, append_dim::Integer)

append append_dim further variables at the end of the argument vector (without specifying their effect, they may e.g. be ignored by the function)

cb_add_append_variables!(self::CBSOCSupportModification, append_dim::Integer)

append append_dim further variables at the end of the argument vector (without effect on the box function, i.e., lower and upper bounds are set to 0)

cb_add_append_vars!(self::CBAFTModification, append_dim::Integer, append_cols::Union{<:CBSparsemat,Nothing}, linear_costs::Union{<:CBMatrix,Nothing})

append @a appenddim new variables/columns with values specified by @a appendcols (NULL: default value) and @a linearcosts coefficients (NULL: default value) by calling Modification::addappend_vars

cb_add_append_vars!(self::CBGroundsetModification, append_dim::Integer, start_val::Union{<:CBMatrix,Nothing} = nothing, costs::Union{<:CBMatrix,Nothing} = nothing)

append @a appenddim new variables with startval as initial values (if NULL, use default value), calls Modification::addappendvars

cb_add_append_vars!(self::CBNNCBoxSupportModification, append_dim::Integer, append_lb::Union{<:CBMatrix,Nothing}, append_ub::Union{<:CBMatrix,Nothing})

append @a append_dim new variables to the box function

cb_add_append_vars!(self::CBPSCAffineModification, append_dim::Integer, append_cols::Union{<:CBSparseCoeffmatMatrix,Nothing})

• @brief append information on new variables at the respective ends

    @param append_dim
           number of variables (or columns ) to
     be appended
  
    @param append_cols
           if NULL, append zero matrices, otherwise it must point to
     a sparse matrix of size new_rowdim() times @a append_dim
           that is to be appended to the constraint matrix on the right
  
    @return number of errors; if errors occured, none of the new changes are performed

cb_add_append_vars!(self::CBSOCSupportModification, append_dim::Integer)

append @a append_dim new variables to the box function

cb_add_apply_factor!(self::CBAFTModification, times_factor::Real)

multiply the current factor by the value @a times_factor (>=0, returns 1 if <0.)

cb_add_coeff!(self::CBMinorant, i::Integer, value::Real)

adds the value to the coefficient in coordinate i

cb_add_coeffs!(self::CBMinorant, n_elements::Integer, values::Union{<:AbstractVector{Real},Nothing}, factor::Real = 1., start_pos::Integer = 0)

adds the n values (possibly multiplied by factor) to consecutive coefficients starting at start_pos (by default 0); this always converts the minroant into a dense vector first and adds then

cb_add_coeffs!(self::CBMinorant, n_elements::Integer, values::Union{<:AbstractVector{Real},Nothing}, indices::Union{<:AbstractVector{Integer},Nothing}, factor::Real = 1.)

adds the n values (possibly multiplied by factor) to the coefficients indicated by indices (if zero, this calls the other add_coeffs for the consecutive version)

cb_add_contributions!(self::CBSumBundleHandler)

• @brief add root parts of this sumbundle to the parent's sumbundle and set the states correspondingly

    If the current mode is child, nothing is done, because it is
    assumed that the sumbundle is already part of the parent. Thus,
    only root parts are considerd new and are added. This is only
    done, if the parenhandler accepts these kind of parts.
  
    When a contribution is added to a parent that is currently
    inactive or child, any respective parent's contributions to the
    parent's parent are first removed and then the mode of the
    parent is set to root. Thus, the parent has to call
    add_contributions afterwards, if it still wants to contribute to
    its own parent.
  
    add_contribution should only be called from
    SumBlockModel::sumbundle_contribution() with a normalized bundle,
    i.e., normalize_sumbundle() should have been called before.

cb_add_delete_blocks!(self::CBPSCAffineModification, del_ind::CBIndexmatrix, map_to_old::CBIndexmatrix)

• @brief delete the rows indexed by the vector delind and return the index changes of the others in a vector mapto_old

    @a del_ind need not be ordered in any way, but any index in 0 to
    new_rowdim()-1 may appear at most once. On output the dimension
    of the column vector @a map_to_old gives the number of remaining
    rows and its entry i holds the index the row with new index i
    had before the deletion. The return value is the number of
    errors in @a del_ind. If such occured, this deletion is not
    performed and @a map_to_old may contain garbage.

cb_add_delete_rows!(self::CBAFTModification, rows_del_ind::CBIndexmatrix, rows_map_to_old::CBIndexmatrix)

delete the rows indexed by @a rowsdelind; for each new index @a rowsmaptoold returns the old one; calls Modification::adddelete_rows

cb_add_delete_vars!(self::CBAFTModification, del_ind::CBIndexmatrix, map_to_old::CBIndexmatrix)

delete the variables indexed by @a delind; for each new index @a maptoold returns the old one; calls Modification::adddelete_vars

cb_add_delete_vars!(self::CBGroundsetModification, del_ind::CBIndexmatrix, map_to_old::CBIndexmatrix)

delete the variables indexed by @a delind; for each new index @a maptoold returns the old one; calls Modification::adddelete_vars

cb_add_delete_vars!(self::CBNNCBoxSupportModification, del_ind::CBIndexmatrix, map_to_old::CBIndexmatrix)

delete the variables indexed by @a delind; for each new index @a maptoold returns the old one; calls Modification::adddelete_vars

cb_add_delete_vars!(self::CBPSCAffineModification, del_ind::CBIndexmatrix, map_to_old::CBIndexmatrix)

• @brief delete the variables indexed by the vector delind and return the index changes of the others in a vector mapto_old

    @a del_ind need not be ordered in any way, but any index in 0 to
    new_vardim()-1 may appear at most once. On output the dimension
    of the column vector @a map_to_old gives the number of remaining
    variables and its entry i holds the index the variable with new
    index i had before the deletion. The return value is the number
    of errors in @a del_ind. If such occured, this deletion is
    not performed and @a map_to_old may contain garbage.

cb_add_delete_vars!(self::CBSOCSupportModification, del_ind::CBIndexmatrix, map_to_old::CBIndexmatrix)

delete the variables indexed by @a delind; for each new index @a maptoold returns the old one; calls Modification::adddelete_vars

cb_add_diagonal_scaling(self::CBAffineFunctionTransformation, diagscale::CBMatrix, indices::Union{<:CBIndexmatrix,Nothing}, alpha::Real, in_diagscale::CBMatrix)

• @brief transform the scaling matrix indiagscale of the untransformed function model and add it as described in BundleMethod::adddiagonal_scaling.

    If indices are given, they must be sorted in striclty increasing order.

cb_add_function!(self::CBMatrixCBSolver, function_::CBFunctionObject, fun_factor::Real = 1., fun_task::CBFunctionTask = cbft_objective_function, aft::Union{<:CBAffineFunctionTransformation,Nothing} = nothing, argument_list_may_change_dynamically::Bool = false)

• @brief Adds a function, typically derived from ConicBundle::FunctionOracle. If the dimension does not match the current one, specify an affine function transformation to map the current ground set to the argument of the function.

  Besides the standard ConicBundle::MatrixFunctionOracle the interface only accepts a few other prespecified derivations of the class FunctionObject that come along with the CHMatrixClasses interface (e.g. for semidefinite and second order cones). Functions not derived from these will fail to be added and return a value !=0.

  The @a funfactor allows to specify a scaling factor for the function. @a funfactor must be a strictly positive number.

  The ConicBundle::FunctionTask @a funtask specifies whether the function is to be used as a an ObjectiveFunction, a ConstantPenaltyFunction with @a funfactor as maximum penalty factor, or as an AdaptivePenaltyFunction with @a fun_factor at initial penalty guess that might be increased or decreased over time.

  The AffineFunctionTransformation @a aft may be used to modify the argument and give an additional affine term (linear term plus offset). For adding an affine term there are several other possibilities, e.g. in init_problem(), so there is no need to do so here. If, however, an existing function implementation requires only some subset of the variables, it is more convenient to supply a corresponding @a aft instead of reimplementing the function.

  @a argumentlistmaychangedynamically sets a flag on how to treat the function arguments when variables are added or deleted. If the arguments may not change, any changes in the variables are mapped to an adaptation of an internal AffineFunctionTransformation so that the function does not notice the changes in the variables. If arguments may change, the function oracle should be a ModifiableOracleObject and react accordingly to the changes in its ModifiableOracleObject::apply_modification() routine.

@return
  - 0 on success
  - != 0 otherwise

cb_add_local_sys!(self::CBUQPConeModelBlock, sysdy::CBSymmatrix, rhs::CBMatrix)

• @brief add the local system informatoin

  on input:
           sysdy= A*barQ^{-1}*A^T    (barQ as returned in add_xinv_kron_z)
           rhs= A*barQ^{-1}*(c-Q*x-A^T*y)-(b-A*x)
  
  if the block uses additional internal variables
  (like an additional term + B*s with s>=0 in the primal feasibility constr)
  then the corresponding block terms have now to be added to sysdy and rhs, eg,
     sysdy +=  B*(t^{-1} kron s)*B^T     (if t is the dual variable to s)
     rhs   +=  B*s - B*(t^{-1} kron s)*B^T*y

cb_add_local_sys!(self::CBUQPSumModelBlock, sysdy::CBSymmatrix, rhs::CBMatrix)

add this for all subblocks

cb_add_localrhs!(self::CBQPConeModelBlock, globalrhs::CBMatrix, rhsmu::Real, rhscorr::Real, startindex_model::Integer, startindex_constraints::Integer, append::Bool, bundle::CBMinorantBundle, startindex_bundel::Integer)

If mu is not zero, always add the centering term for this mu as well, if append is false, add the Schur complement rhs for addBtinvsysB, if append is true, fill in the rhs of the local system starting at startindex for the model and at startindexconstraints for the modelconstraints

cb_add_localrhs!(self::CBQPSumModelBlock, globalrhs::CBMatrix, rhsmu::Real, rhscorr::Real, startindex_model::Integer, startindex_constraints::Integer, append::Bool, bundle::CBMinorantBundle, startindex_bundel::Integer)

If mu is not zero, always add the centering term for this mu as well, if append is false, add the Schur complement rhs for addBtinvsysB, if append is true, fill in the rhs of the local system starting at startindex for the model and at startindexconstraints for the modelconstraints

cb_add_localsys!(self::CBQPConeModelBlock, globalsys::CBSymmatrix, startindex_model::Integer, startindex_constraints::Integer)

add the local system for the model at startindex, the local for the constraints at startindex_constraints

cb_add_localsys!(self::CBQPSumModelBlock, globalsys::CBSymmatrix, startindex_model::Integer, startindex_constraints::Integer)

virtual int addBtinvsysB(CHMatrix_Classes::Symmatrix& globalsys);

cb_add_model!(self::CBSumModel, model::Union{<:CBSumBlockModel,Nothing})

adds the @a model as submodel to this model (if this model may have submodels); if any error occurs the model is not added

cb_add_modelx_aggregate!(self::CBQPConeModelBlock, vec::CBMatrix, global_bundle::CBMinorantBundle, startindex_bundle::Integer)

adds opB transposed times modelx (with offsets but without constant affine term) to the arguments

cb_add_modelx_aggregate!(self::CBQPSumModelBlock, vec::CBMatrix, global_bundle::CBMinorantBundle, startindex_bundle::Integer)

adds opB transposed times modelx (without constant affine term) to the arguments

cb_add_modelx_aggregate!(self::CBUQPConeModelBlock, gradient::CBMatrix)

adds opB transposed times modelx (with offsets but without constant affine term) to the arguments

cb_add_modelx_aggregate!(self::CBUQPSumModelBlock, gradient::CBMatrix)

do this for all subblocks

cb_add_offset!(self::CBAFTModification, delta::Real)

add to the currecnt offset the value @a delta

cb_add_offset!(self::CBGroundsetModification, delta::Real)

add to the current offset the value @a delta

cb_add_offset!(self::CBMinorantPointer, offset::Real)

add the offset; if empty, initialize to offset with zero linear part, if not the only user (use_cnt>1), clone it first

cb_add_offset!(self::CBMinorant, value::Real)

adds this value to the current offset value

cb_add_projection(self::CBCMgramdense, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_projection(self::CBCMgramsparse, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_projection(self::CBCMgramsparse_withoutdiag, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_projection(self::CBCMlowrankdd, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_projection(self::CBCMlowranksd, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_projection(self::CBCMlowrankss, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_projection(self::CBCMsingleton, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_projection(self::CBCMsymdense, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_projection(self::CBCMsymsparse, S::CBSymmatrix, P::CBMatrix, alpha::Real = 1., start_row::Integer = 0)

computes S+=Q^T(*this)Q for Q=P.rows(startrow,startrow+dim-1)

cb_add_reassign_blocks!(self::CBPSCAffineModification, map_to_old::CBIndexmatrix)

• @brief reassign the current row indices (with modifications) as specified by @a maptoold

    @a map_to_old must specify an injective map (no two values
    match) into indices 0 up to new_rowdim()-1 (not all need to
    appear).  The row getting index i (for i=0 to
    map_to_old.dim()-1) is the row with current index map_to_old(i)
    (current refers to considering all previous modifications as
    having been carried out already). The return value is the number
    of errors in @a map_to_old. If such occured, this reassign is
    not performed.

cb_add_reassign_rows!(self::CBAFTModification, map_to_old::CBIndexmatrix)

reassign the rows as given in @a maptoold, calls Modification::addreassignvars

cb_add_reassign_variables!(self::CBAFTModification, new_dim::Integer, map_to_old_indices::Union{<:AbstractVector{Integer},Nothing})

reorder and resize the variables as given by the first newdim entries of maptooldindices; each former index may appear at most once in this list, so newdim < getnew_vardim()

cb_add_reassign_variables!(self::CBGroundsetModification, new_dim::Integer, map_to_old_indices::Union{<:AbstractVector{Integer},Nothing})

reorder and resize the variables as given by the first newdim entries of maptooldindices; each former index may appear at most once in this list, so newdim < getnew_vardim()

cb_add_reassign_variables!(self::CBNNCBoxSupportModification, new_dim::Integer, map_to_old_indices::Union{<:AbstractVector{Integer},Nothing})

reorder and resize the variables as given by the first newdim entries of maptooldindices; each former index may appear at most once in this list, so newdim < getnew_vardim()

cb_add_reassign_variables!(self::CBPSCAffineModification, new_dim::Integer, map_to_old_indices::Union{<:AbstractVector{Integer},Nothing})

reorder and resize the variables as given by the first newdim entries of maptooldindices; each former index may appear at most once in this list, so newdim < getnew_vardim()

cb_add_reassign_variables!(self::CBSOCSupportModification, new_dim::Integer, map_to_old_indices::Union{<:AbstractVector{Integer},Nothing})

reorder and resize the variables as given by the first newdim entries of maptooldindices; each former index may appear at most once in this list, so newdim < getnew_vardim()

cb_add_reassign_vars!(self::CBAFTModification, map_to_old::CBIndexmatrix)

reassign the variables/columns as given in @a maptoold, calls Modification::addreassignvars

cb_add_reassign_vars!(self::CBGroundsetModification, map_to_old::CBIndexmatrix)

reassign the variables as given in @a maptoold, calls Modification::addreassignvars

cb_add_reassign_vars!(self::CBNNCBoxSupportModification, map_to_old::CBIndexmatrix)

reassign the variables as given in @a maptoold, calls Modification::addreassignvars

cb_add_reassign_vars!(self::CBPSCAffineModification, map_to_old::CBIndexmatrix)

• @brief reassign the current variable indices (with modifications) as specified by @a maptoold

    @a map_to_old must specify an injective map (no two values match)
    into indices 0 up to new_vardim()-1 (not all need to appear). The variable getting index
    i (for i=0 to map_to_old.dim()-1) is the variable with current
    index map_to_old(i) (current refers to considering all previous
    modifications as having been carried out already). The return
    value is the number of errors in @a map_to_old. If such occured, this
    reassign is not performed.

cb_add_reassign_vars!(self::CBSOCSupportModification, map_to_old::CBIndexmatrix)

reassign the variables as given in @a maptoold, calls Modification::addreassignvars

cb_add_reset_generating_primal!(self::CBPSCAffineModification, new_generating_primal::Union{<:CBPSCPrimal,Nothing})

• @brief replace the current generating primal by newgeneratingprimal (on the heap, will be deleted here). It may be NULL to switch of generating primals.

    Any changes here cause the deletion of all current aggregate minorants.
    If not NULL, the object pointed to is on the heap and control over it
    is passed over to *this, so *this will make sure it is deleted at due
    time.
  
    PSCPrimal gives no information on the order of the matrices involved, so no consistency checks are done here.

cb_add_solver!(self::CBQPKKTSolverComparison, solver::Union{<:CBQPKKTSolverObject,Nothing}, name::Union{<:AbstractVector{UInt8},Nothing})

the first solver added is the reference solver

cb_add_variable_metric!(self::CBBundleDenseTrustRegionProx, addH::CBSymmatrix)

see BundleProxObject::addvariablemetric()

cb_add_variable_metric!(self::CBBundleDenseTrustRegionProx, diagH::CBMatrix, vecH::CBMatrix)

see BundleProxObject::addlowrankvariable_metric()

cb_add_variable_metric!(self::CBBundleDiagonalTrustRegionProx, diagH::CBMatrix, vecH::CBMatrix)

see BundleProxObject::adddynamicscaling()

cb_add_variable_metric!(self::CBBundleDLRTrustRegionProx, diagH::CBMatrix, vecH::CBMatrix)

see BundleProxObject::addvariablemetric()

cb_add_variable_metric!(self::CBBundleLowRankTrustRegionProx, diagH::CBMatrix, vecH::CBMatrix)

see BundleProxObject::adddynamicscaling()

cb_add_variable_metric!(self::CBLPGroundset, H::CBVariableMetric, y_id::Integer, y::CBMatrix, descent_step::Bool, weightu::Real, model_maxviol::Real, indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see VariableMetric

cb_add_variable_metric!(self::CBAFTModel, H::CBVariableMetric, center_id::Integer, y::CBMatrix, descent_step::Bool, weightu::Real, model_maxviol::Real, indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see DynamicScaling

cb_add_variable_metric!(self::CBSumModel, H::CBVariableMetric, y_id::Integer, y::CBMatrix, descent_step::Bool, weightu::Real, model_maxviol::Real, indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see BundleModel::adddynamicscaling

cb_add_variable_metric!(self::CBPSCVariableMetricSelection, H::CBVariableMetric, y_id::Integer, y::CBMatrix, descent_step::Bool, weightu::Real, model_maxviol::Real, indices::Union{<:CBIndexmatrix,Nothing}, bundle_data::CBVariableMetricBundleData)

see ConicBundle::VariableMetricSelection::addvariablemetric(); here it must be possible to cast bundledata to PSCData&, otherwise the routine returns an error. It only adds something after a descentstep

cb_add_variable_metric!(self::CBVariableMetricSVDSelection, H::CBVariableMetric, y_id::Integer, y::CBMatrix, descent_step::Bool, weightu::Real, model_maxviol::Real, indices::Union{<:CBIndexmatrix,Nothing}, bundle_data::CBVariableMetricBundleData)

see ConicBundle::VariableMetricSelection::addvariablemetric()

cb_add_variable_metric!(self::CBSumBundleHandler, ft::CBFunctionTask, H::CBVariableMetric, yid::Integer, y::CBMatrix, descent_step::Bool, weightu::Real, model_maxviol::Real, indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see DynamicScaling

cb_add_variable_metric!(self::CBSumBundleHandler, H::CBVariableMetric, yid::Integer, center_y::CBMatrix, descent_step::Bool, weightu::Real, model_maxviol::Real, indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see DynamicScaling

cb_add_xinv_kron_z!(self::CBUQPConeModelBlock, barQ::CBSymmatrix)

add the system term corresponding to (xinv kron z) (that arises from solving the linearized perturbed complementarity system xz =0 or =muI for dx in the preferred search direction) to the diagonal block corresponding to qpxrange x qpxrange

cb_add_xinv_kron_z!(self::CBUQPSumModelBlock, barQ::CBSymmatrix)

add this for all subblocks

cb_addmeto(self::CBCMgramdense, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addmeto(self::CBCMgramsparse, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addmeto(self::CBCMgramsparse_withoutdiag, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addmeto(self::CBCMlowrankdd, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addmeto(self::CBCMlowranksd, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addmeto(self::CBCMlowrankss, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addmeto(self::CBCMsingleton, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addmeto(self::CBCMsymdense, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addmeto(self::CBCMsymsparse, S::CBSymmatrix, d::Real = 1.)

computes S+=d(this);

cb_addprodto(self::CBCMgramdense, B::CBMatrix, C::CBMatrix, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMgramdense, B::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMgramsparse, B::CBMatrix, C::CBMatrix, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMgramsparse, B::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMgramsparse_withoutdiag, B::CBMatrix, C::CBMatrix, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMgramsparse_withoutdiag, B::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMlowrankdd, D::CBMatrix, C::CBMatrix, d::Real = 1.)

computes D+=d(this)*C

cb_addprodto(self::CBCMlowrankdd, D::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes D+=d(this)*C

cb_addprodto(self::CBCMlowranksd, D::CBMatrix, C::CBMatrix, d::Real = 1.)

computes D+=d(this)*C

cb_addprodto(self::CBCMlowranksd, D::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes D+=d(this)*C

cb_addprodto(self::CBCMlowrankss, D::CBMatrix, C::CBMatrix, d::Real = 1.)

computes D+=d(this)*C

cb_addprodto(self::CBCMlowrankss, D::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes D+=d(this)*C

cb_addprodto(self::CBCMsingleton, B::CBMatrix, C::CBMatrix, d::Real = 1.)

comutes B+=d(this)*C

cb_addprodto(self::CBCMsingleton, B::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMsymdense, B::CBMatrix, C::CBMatrix, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMsymdense, B::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMsymsparse, B::CBMatrix, C::CBMatrix, d::Real = 1.)

computes B+=d(this)*C

cb_addprodto(self::CBCMsymsparse, B::CBMatrix, C::CBSparsemat, d::Real = 1.)

computes B+=d(this)*C

cb_adjust_multiplier!(self::CBMatrixCBSolver)

• @brief Adjusts on all conic functions the penalty parameter for conic violations to twice the trace of the primal approximation.

    This routine is only needed for conic function objects such
    as the nonnegative cone, the second order cone and
    the semidefinite cone if no good upper bound on the trace of
    feasible points is known and has to be determined automatically.
  
    If after some time, the trace values settle, the upper bounds
    on the trace may be way to high and can then be reset with this
    call.
  
  @return
    - 0 on success
    - != 0 otherwise

cb_adjust_multiplier!(self::CBAFTModel, values_may_have_changed::Bool)

see SumBlockModel::adjust_multiplier

cb_adjust_multiplier!(self::CBSumModel, values_may_have_changed::Bool)

see SumBlockModel::adjust_multiplier()

cb_adjust_multiplier!(self::CBSumBundleHandler, values_may_have_changed::Bool)

see SumBlockModel::adjust_multiplier

cb_adjust_trace!(self::CBQPConeModelBlock, b::Real)

change the right hand side of the trace constraint to b

cb_adjust_trace!(self::CBUQPConeModelBlock, b::Real)

change the right hand side of the trace constraint to b

cb_aggregate(self::CBMinorantPointer)

*@brief returns ture if it points to a combination of minorants from the same function;

   A minorant is considered an aggregate if it is obtained from an aggregate
   or it was computed by a call to aggregate(MinorantBundle&,Real);
   It is not an aggregate if it is the sum of non aggregate minorants from
   different functions.

   An _empty_ pointer is not an aggregate.

cb_aggregate(self::CBMinorantUseData)

returns true if the minorant is an aggregate of several minorants

cb_aggregate!(self::CBMinorantPointer, minorants::CBMinorantBundle, coeff::CBMatrix, factor::Real = 1.)

*@brief collect the aggregate as the nonnegative linear combination of the bundle minorants (here *this may not be part of the bundle!). If *this is not empty, add this aggregate to *this. Only aggregation carries along primal data!

   All minorants in the bundle need to be valid. Aggregating over no minorants
   is treated as a zero minorant without any primal information.

cb_aggregate!(self::CBMinorantPointer, minorant::CBMinorantPointer, itsfactor::Real = 1.)

@brief aggregate the minorantitsfactor to *this, both must be valid for this. Only aggregation carries along primal data!

cb_aggregate!(self::CBMinorant, minorant::CBMinorant, factor::Real = 1.)

adds factor*minorant to this and does this also for the primal if it is availabe

cb_aggregate_Gram_matrix!(self::CBBlockPSCPrimal, P::CBMatrix, factor::Real = 1.)

@brief add factorP*P^T to this

   The rows of P corresponding to each block are passed on the
   with a corresponding call to the PSCPrimal of this block

cb_aggregate_Gram_matrix!(self::CBDensePSCPrimal, P::CBMatrix, factor::Real = 1.)

add factorPP^T to this

cb_aggregate_Gram_matrix!(self::CBGramSparsePSCPrimal, P::CBMatrix, factor::Real = 1.)

@brief add factorP*P^T to this, collecting all available information only in the sparse part, even the own Gram part.

   This operation more or less converts this to a SparsePSCPrimal. The point
   is that this routine is typically only called by PSCModel when aggregating
   the information in a single aggregate matrix over several steps and it is
   pointless to try to keep any gram information in this case.

cb_aggregate_Gram_matrix!(self::CBSparsePSCPrimal, P::CBMatrix, factor::Real = 1.)

add factorPP^T on the support to this

cb_aggregate_primal_data!(self::CBPrimalMatrix, it::CBPrimalData, itsfactor::Real)

multiply this Matrix with myfactor and add itsfactorit (it must dynamic_cast to a PrimalMatrix)

cb_aggregate_primal_data!(self::CBBlockPSCPrimal, it::CBPrimalData, factor::Real = 1.)

• add factor*it to this (it must also be a BlockPSCPrimal with the same block partition)

cb_aggregate_primal_data!(self::CBDensePSCPrimal, it::CBPrimalData, factor::Real = 1.)

add factor*it to this (it must also be a DensePSCPrimal)

cb_aggregate_primal_data!(self::CBGramSparsePSCPrimal, it::CBPrimalData, factor::Real = 1.)

@brief if it is a GramSparsePSCPrimal or SparseSDPRimal, add factorit to this on only the support of this sparsematrix

   Even if it is a GramSparsePSCPrimal and it has a nontirival Gram matrix part,
   this part is only added to the sparse part of this on the support of the
   sparse part of this. No attempt is made to enlarge the Gram part.

cb_aggregate_primal_data!(self::CBSparsePSCPrimal, it::CBPrimalData, factor::Real = 1.)

if it is a SparseSDPRimal, add factor*it to this on the support of this

cb_aggregated!(self::CBMinorantUseData, n::Integer)

add @a n to the number couting the aggregations

cb_analyze_modification(self::CBAffineFunctionTransformation, minorant_trafo_differs::Bool, aftmdf::Union{<:CBAFTModification,Nothing}, gsmdf::CBGroundsetModification)

• @brief returns information on the changes in the ground set of the transformed arguments and checks whether after the modification the nonzero image of the transformed minorants will not differ from before; returns NULL on errors.

  If argtrafo==NULL (act as identity) and if aftmdf!=NULL adds any explicit matrix parts or has modifications not consistent with maintaining the identity, argtrafo is virtually first set to an explicit identity before executing the modification. If argtrafo==NULL and aftmdf==NULL, the transformations of gsmdf are applied to linearcost and arg_offset.

  If the input @a gsmdf and the AFT modifications in @a aftmdf result in a different GroundsetModification of the transformed space, this is computed into the member @a localgsmdf and the returned pointer points to this @a localgsmdf. If all transformations are passed on exactly as in @a gsmdf (because the trafo still acts as the identity), the returned pointer points to @a gsmdf.

    If the changes affect the transformation at all in its effect

  on the nonzero image of transformed minorants, @a minoranttrafodiffers will be set to true otherwise to false.

cb_append!(self::CBQPSumModelBlock, inblock::Union{<:CBQPModelDataObject,Nothing})

add another model at the end of the list

cb_append!(self::CBUQPSumModelBlock, inblock::Union{<:CBQPModelDataObject,Nothing})

add another model at the end of the list

cb_append_blocks!(self::CBSparseCoeffmatMatrix, append_mat::CBSparseCoeffmatMatrix, blocks::Union{<:CBIndexmatrix,Nothing} = nothing, cols::Union{<:CBIndexmatrix,Nothing} = nothing)

• @brief append append_mat (or its submatrix given by blocks and/or cols) below

    If blocks or cols have negative entries, each of these represent a row of blocks of zeros whose order is the negative of the given value or a column of zeros of appropriate size (the size of the negative value does not matter for columns)

cb_append_columns!(self::CBSparseCoeffmatMatrix, append_mat::CBSparseCoeffmatMatrix, blocks::Union{<:CBIndexmatrix,Nothing} = nothing, cols::Union{<:CBIndexmatrix,Nothing} = nothing)

• @brief append append_mat (or its submatrix given by blocks and/or cols) to the right

    If blocks or cols have negative entries, each of these represent a row of blocks of zeros whose order is the negative of the given value (if columns exist already, these need to match the order of the existing blocks) or a column of zeros of appropriate size (the size of the negative value does not matter for columns)

cb_append_constraints!(self::CBMatrixCBSolver, append_n_rows::Integer, append_rows::Union{<:CBSparsemat,Nothing} = nothing, append_rhslb::Union{<:CBMatrix,Nothing} = nothing, append_rhsub::Union{<:CBMatrix,Nothing} = nothing)

• @brief append \f$rhslb\le Ay \le rhsub\f$ as linear constraints on the groundset variables \f$y\f$. \f$A\f$ has @a appendnrows new rows with coefficients given in appendrows (if NULL, use default value), lower bounds appendrhslb (if NULL use default) and upper bounds append_rhsub (if NULL use default)

  @param[in] appendnrows (Integer) (nonnegative) number of rows to be appended as linear constraints on the ground set

  @param[in] appendrows (Sparsemat*) describes the coefficients of the linear constraints; the number of rows must match appendn_rows, the number of columns must match the current dimension of the groundset; if NULL, all coefficients are considered zero.

  @param[in] appendrhslb (Matrix*) specifies lower bounds on the values of the constraints; the number of rows must match appendnrows; if NULL, all coefficients are considered CBminus_infinity.

  @param[in] appendrhsub (Matrix*) specifies upper bound on the values of the constraints; the number of rows must match appendnrows; if NULL, all coefficients are considered CBplus_infinity.

  @return - 0 on success - != 0 otherwise

cb_append_to_old(self::CBAFTModification)

returns true if this only contains appending operations and incorporating this is done with respect to the old dimension

cb_append_to_old(self::CBGroundsetModification)

returns true if this only contains appending operations and incorporating this is done with respect to the old dimension

cb_append_to_old(self::CBNNCBoxSupportModification)

returns true if this only contains appending operations and incorporating this is done with respect to the old dimension

cb_append_to_old(self::CBPSCAffineModification)

returns true if this only contains appending operations and incorporating this is done with respect to the old dimension

cb_append_to_old(self::CBSOCSupportModification)

returns true if this only contains appending operations and incorporating this is done with respect to the old dimension

cb_append_variables!(self::CBMatrixCBSolver, n_append::Integer, lbounds::Union{<:CBMatrix,Nothing} = nothing, ubounds::Union{<:CBMatrix,Nothing} = nothing, constraint_columns::Union{<:CBSparsemat,Nothing} = nothing, startval::Union{<:CBMatrix,Nothing} = nothing, costs::Union{<:CBMatrix,Nothing} = nothing)

• @brief Append new variables (always in last postions in this order).

  @attention Be sure to include a desription of required changes to your functions via @a affectedfunctionswith_modifications

  @param[in] n_append (int) number of variables to append (always in last position in the same order)

  @param[in] lbounds (const Matrix*) If NULL, all appended variables are considered unbounded below, otherwise lbounds[i] gives the minimum feasible value for variable y[i], use ConicBundle::CBminusinfinity for unbounded below.

  @param[in] ubounds (const Matrix*) If NULL, all appended variables are considered unbounded above, otherwise ubounds[i] gives the maximum feasible value for variable y[i], use ConicBundle::CBplusinfinity for unbounded above.

  @param[in] constraintcolumns (const Sparsemat*) This must be NULL unless appendconstraints() has been used before for specifying linear constraints on the ground set; if there are constraints, NULL is interpreted as appending zero columns to the constraints, otherwise the the number of rows of the Sparsemant has to match the current number of linear constraints and the number of columns the must equal n_append.

  @param[in] startval (const Matrix*) If NULL, the starting values are obtained by projecting zero onto the feasible set given by the lower and upper bounds resulting from the arguments before

  @param[in] costs (const Matrix*) Use this in order to specify linear costs on the variables in addition to the functions (may be convenient in Lagrangean relaxation for the right hand side of coupling contsraints); NULL is equivalent to costs zero.

  @param[in,out] affectedfunctionswithmodifications (const FunObjModMap*) If NULL, default actions are performed on all functions. In particular, those admitting dynamic argument changes will get the new variables appended at the end of their argument vector and (eventually) their applymodification() routines will be called informing them about the groundset changes; for those not admitting changes in their arguments, their corresponding (possibly newly created) affine function transformation will be set up to ignore the new arguments. If !=NULL, for the listed functions (and their parents up to the root function) the default appending action is performed unless their FunctionObjectModification entry gives explicit modification instructions which are then applied instead. For all functions NOT listed in the map and not having modified offsprings their corresponding aft will be set up to ignore the new variables.

  @return - 0 on success - != 0 otherwise

cb_appended_blockdim(self::CBPSCAffineModification)

returns the number of rows that are appended (due to later reassignments they may no longer be located at the end)

cb_appended_rowdim(self::CBAFTModification)

returns the number of rows that are appended (due to later reassignments they may no longer be located at the end)

cb_appended_vardim(self::CBAFTModification)

returns the number of variables that are appended (due to later reassignmentds they may no longer be located at the end)

cb_appended_vardim(self::CBGroundsetModification)

returns the number of variables that are appended (due to later reassignmentds they may no longer be located at the end)

cb_appended_vardim(self::CBNNCBoxSupportModification)

returns the number of variables that are appended (due to later reassignmentds they may no longer be located at the end)

cb_appended_vardim(self::CBPSCAffineModification)

returns the number of variables that are appended (due to later reassignmentds they may no longer be located at the end)

cb_appended_vardim(self::CBSOCSupportModification)

returns the number of variables that are appended (due to later reassignmentds they may no longer be located at the end)

cb_apply_Hinv(self::CBBundleDenseTrustRegionProx, x::CBMatrix)

returns \f$H^{-1}x\f$

cb_apply_Hinv(self::CBBundleDiagonalTrustRegionProx, x::CBMatrix)

returns \f$H^{-1}x\f$

cb_apply_Hinv(self::CBBundleDLRTrustRegionProx, x::CBMatrix)

returns \f$H^{-1}x\f$ where \f$H^{-1}=\frac1u(I-V(\Lambda/(\Lambda+u))V^\top)\f$

cb_apply_Hinv(self::CBBundleIdProx, x::CBMatrix)

returns \f$H^{-1}x\f$

cb_apply_Hinv(self::CBBundleLowRankTrustRegionProx, x::CBMatrix)

returns \f$H^{-1}x\f$ where \f$H^{-1}=\frac1u(I-V(\Lambda/(\Lambda+u))V^\top)\f$

cb_apply_modification!(self::CBAffineFunctionTransformation, aftmdf::Union{<:CBAFTModification,Nothing}, gsmdf::CBGroundsetModification)

• @brief if argtrafo==NULL (act as identity) and if aftmdf!=NULL adds any explicit matrix parts or has modifications not consistent with maintaining the identity, argtrafo is first set to an explicit identity before executing the modification. If argtrafo==NULL and aftmdf==NULL, the transformations of gsmdf are applied to linearcost and arg_offset.

cb_apply_modification!(self::CBMinorantPointer, gsmdf::CBGroundsetModification, mod_id::Integer, mex::Union{<:CBMinorantExtender,Nothing}, apply_gsmdf_costs::Bool = false)

if valid and the local modificationid is smaller than modid, it modifies the coefficients as described by GroundsetModification; if successful, the modid is assigend and the function returns 0; otherwise it is invalidated and returns !=0; the costs of gsmdf are used only if applygsmdf_costs=false in whic case mex must be NULL

cb_apply_modification!(self::CBBoxData, param0::CBGroundsetModification, mex::Union{<:CBMinorantExtender,Nothing})

rearrange/extend the minorants according to the given groundset modifications

cb_apply_modification!(self::CBNNCData, param0::CBGroundsetModification, mex::Union{<:CBMinorantExtender,Nothing})

rearrange/extend the minorants according to the given groundset modifications

cb_apply_modification!(self::CBPSCData, param0::CBGroundsetModification, mex::Union{<:CBMinorantExtender,Nothing})

rearrange/extend the minorants according to the given groundset modifications

cb_apply_modification!(self::CBSOCData, param0::CBGroundsetModification, mex::Union{<:CBMinorantExtender,Nothing})

rearrange/extend the minorants according to the given groundset modifications

cb_apply_modification!(self::CBBundleHKWeight, gsmdf::CBGroundsetModification)

reinitialize after modifications

cb_apply_modification!(self::CBBundleRQBWeight, gsmdf::CBGroundsetModification)

reinitialize after modifications

cb_apply_modification!(self::CBBundleDenseTrustRegionProx, gsmdf::CBGroundsetModification)

when BundleSolver is called to modify the groundset it also calls this

cb_apply_modification!(self::CBBundleDiagonalTrustRegionProx, gsmdf::CBGroundsetModification)

when BundleSolver is called to modify the groundset it also calls this

cb_apply_modification!(self::CBBundleDLRTrustRegionProx, gsmdf::CBGroundsetModification)

when BundleSolver is called to modify the groundset it also calls this

cb_apply_modification!(self::CBBundleIdProx, gsmdf::CBGroundsetModification)

when BundleSolver is called to modify the groundset it also calls this

cb_apply_modification!(self::CBBundleLowRankTrustRegionProx, gsmdf::CBGroundsetModification)

when BundleSolver is called to modify the groundset it also calls this

cb_apply_modification!(self::CBUQPSolver, param0::CBGroundsetModification)

does nothing here (unconstrained case)

cb_apply_modification!(self::CBLPGroundset, mdf::CBGroundsetModification)

change the groundset description as specified by the argument

cb_apply_modification!(self::CBUnconstrainedGroundset, mdf::CBGroundsetModification)

change the groundset description as specified by the argument

cb_apply_modification!(self::CBSumBundle, gsmdf::CBGroundsetModification, mod_id::Integer, mex::Union{<:CBMinorantExtender,Nothing}, ft::CBFunctionTask)

rearrange/extend the minorants according to the given groundset modifications

cb_apply_modification!(self::CBBundleSolver, gsmdf::CBGroundsetModification)

modify the groundset as described by GroundsetModification and inform the oracle function(s) about this change (calls the other apply_modification for an empty FunObjModMap)

cb_apply_modified_transform(self::CBAFTModification, out_y::CBMatrix, in_y::CBMatrix, arg_trafo::Union{<:CBSparsemat,Nothing}, arg_offset::Union{<:CBMatrix,Nothing})

transform the vector as if the Modification had been carried out

cb_apply_to_PSCAffine(self::CBPSCAffineModification, offset::Union{<:CBSparseCoeffmatMatrix,Nothing}, matrix::Union{<:CBSparseCoeffmatMatrix,Nothing})

• @brief carry out the collected modifications on the data describing the PSCAffineFunction

     If a specific parameter is NULL, no changes are performed on it,
     if it is not null, it must point to a SparseCoeffmatMatrix
     whose sizes correspond to the "old" data. Then the following
     operations will be performed on it in this sequence:
  
     1. new variables (columns) are appended to the matrix
  
     2. if reassignment information is given, the columns are
        mapped/reorderd as given by *map_to_old_variables()
  
     3. new blocks (rows) are appended to the offset and the matrix
  
     4. if reassignment information is given, the rows are
        mappen/reorderd as given by *map_to_old_blocks()
  
     @param[in,out] offset
        if not NULL, this points to the offset vector.
  
     @param[in,out] matrix
        if not NULL, this points to the old matrix.
  
     @return the number of dimension errors of non NULL inputs,
        if any, no modifications are made to any inputs.

cb_apply_to_bounds(self::CBNNCBoxSupportModification, lb::CBMatrix, ub::CBMatrix)

carry out the collected modifications on the given vectors of lower and upper bounds on the variables by calling Modification::applytovars

cb_apply_to_costs(self::CBGroundsetModification, costs::CBMatrix)

carry out the collected modifications on the given vector by calling Modification::applytovars

cb_apply_to_factor(self::CBAFTModification)

multiply @a f by the factor

cb_apply_to_offset(self::CBAFTModification)

add to @a o the offset

cb_apply_to_vars(self::CBGroundsetModification, vars::CBMatrix)

carry out the collected modifications on the given vector by calling Modification::applytovars

cb_apply_variable_metric!(self::CBBundleDenseTrustRegionProx, groundset::Union{<:CBVariableMetricModel,Nothing}, model::Union{<:CBVariableMetricModel,Nothing}, aggr::CBMatrix, y_id::Integer, y::CBMatrix, descent_step::Bool, model_maxviol::Real, new_indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see DynamicScaling

cb_apply_variable_metric!(self::CBBundleDiagonalTrustRegionProx, groundset::Union{<:CBVariableMetricModel,Nothing}, model::Union{<:CBVariableMetricModel,Nothing}, aggr::CBMatrix, y_id::Integer, y::CBMatrix, descent_step::Bool, model_maxviol::Real, new_indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see VariableMetric

cb_apply_variable_metric!(self::CBBundleDLRTrustRegionProx, groundset::Union{<:CBVariableMetricModel,Nothing}, model::Union{<:CBVariableMetricModel,Nothing}, aggr::CBMatrix, y_id::Integer, y::CBMatrix, descent_step::Bool, model_maxviol::Real, new_indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see DynamicScaling

cb_apply_variable_metric!(self::CBBundleLowRankTrustRegionProx, groundset::Union{<:CBVariableMetricModel,Nothing}, model::Union{<:CBVariableMetricModel,Nothing}, aggr::CBMatrix, y_id::Integer, y::CBMatrix, descent_step::Bool, model_maxviol::Real, new_indices::Union{<:CBIndexmatrix,Nothing} = nothing)

see DynamicProx

cb_argument_changes(self::CBAffineFunctionTransformation)

returns true if not the identity

cb_assign_Gram_matrix!(self::CBBlockPSCPrimal, P::CBMatrix)

*@brief for each element aij in the support set aij=<P.row(i),P.row(j)>

   The rows of P corresponding to each block are passed on the
   with a corresponding call to the PSCPrimal of this block

cb_assign_Gram_matrix!(self::CBDensePSCPrimal, P::CBMatrix)

assign P*P^T to this

cb_assign_Gram_matrix!(self::CBGramSparsePSCPrimal, P::CBMatrix)

Set the grammatrix part to \f$P\f$ and set all values on the sparse support to zero (but keep this support even if it is zero now!)

cb_assign_Gram_matrix!(self::CBSparsePSCPrimal, P::CBMatrix)

for each element aij in the support set aij=<P.row(i),P.row(j)>

cb_block(self::CBBlockPSCPrimal, i::Integer)

returns the PSCPrimal of block i if there is one, 0 otherwise

cb_block_modifications(self::CBPSCAffineModification)

returns true if some modifications are performed on the block structure

cb_blockdim(self::CBSparseCoeffmatMatrix)

returns a column vector with row i giving the order of block i

cb_blockdim(self::CBSparseCoeffmatMatrix, i::Integer)

returns the order of block i

cb_blockdim(self::CBBlockPSCPrimal, i::Integer)

returns the size of block i

cb_bundle_size(self::CBSumBundle, ft::CBFunctionTask)

if BData exists for this mode it returns its bundle_size (possibly 0), otherwise 0

cb_call_primal_extender!(self::CBMatrixCBSolver, function_::CBFunctionObject, primal_extender::CBPrimalExtender)

• @brief Asks @a function to call @a primal_extender for each of its primal objects (see also FunctionOracle::evaluate() )

  If the function is the Lagrangian dual of a primal problem and primaldata returned previous calls to the oracle has now to be updated due to changes in the primal problem – e.g., this may happen in column generation – the call causes updates of all internally stored primaldata objects by calling PrimalExtender::extend on each of these.

  @param[in] function (const FunctionObject&)
    the function added in add_function()
  
  @param[in] primal_extender (PrimalExtender&)
    the object holding the extension function for primal_data
  
  @return
    - 0 on success
    - 1 if for this function it is not possible to use a primal_extender
    - 2 if the primal_extender would be applicable but there is no primal_data

cb_call_primal_extender!(self::CBMinorantPointer, prex::CBPrimalExtender, prex_id::Integer)

executes prex on the primal if its id is smaller then prex_id; returns != if this fails or not primal data is available

cb_call_primal_extender!(self::CBMinorantUseData, prex::CBPrimalExtender, in_prex_id::Integer)

apply the primal extender to the minorant if @a inprexid indicates a new extension

cb_call_primal_extender!(self::CBBoxData, prex::CBPrimalExtender, include_candidates::Bool = true)

see the last argument of BoxOracle::evaluate()

cb_call_primal_extender!(self::CBNNCData, prex::CBPrimalExtender, include_candidates::Bool = true)

see the last argument of FunctionOracle::evaluate()

cb_call_primal_extender!(self::CBPSCData, param0::CBPrimalExtender, include_candidates::Bool = true)

see the last argument of FunctionOracle::evaluate()

cb_call_primal_extender!(self::CBSOCData, param0::CBPrimalExtender, include_candidates::Bool = true)

see the last argument of FunctionOracle::evaluate()

cb_call_primal_extender!(self::CBAFTModel, param0::CBPrimalExtender)

an AFT has no primals, so it returns 1, see SumBlockModel::callprimalextender

cb_call_primal_extender!(self::CBBoxModel, prex::CBPrimalExtender)

see SumBlockModel::callprimalextender

cb_call_primal_extender!(self::CBNNCModel, prex::CBPrimalExtender)

see SumBlockModel::callprimalextender

cb_call_primal_extender!(self::CBPSCModel, prex::CBPrimalExtender)

see SumBlockModel::callprimalextender

cb_call_primal_extender!(self::CBSOCModel, prex::CBPrimalExtender)

see SumBlockModel::callprimalextender

cb_call_primal_extender!(self::CBSumModel, param0::CBPrimalExtender)

this has no primals, so it returns 1, see SumBlockModel::callprimalextender

cb_call_primal_extender!(self::CBSumBundle, prex::CBPrimalExtender, prex_id::Integer, ft::CBFunctionTask)

call this primal extender for the primals; if there minorants but no primals or if it fails, return 1

cb_candidate!(self::CBLPGroundset, newy::CBMatrix, center_y::CBMatrix, center_value::Real, model_minorant::CBMinorantPointer, Hp::Union{<:CBBundleProxObject,Nothing}, delta_groundset_minorant::Union{<:CBMinorantPointer,Nothing} = nothing, delta_index::Union{<:CBIndexmatrix,Nothing} = nothing, relprec::Real = 1e-2)

computes the next ground set minorant and candidate, see Groundset::candidate()

cb_candidate!(self::CBUnconstrainedGroundset, newy::CBMatrix, center_y::CBMatrix, center_value::Real, model_minorant::CBMinorantPointer, Hp::Union{<:CBBundleProxObject,Nothing}, delta_groundset_minorant::Union{<:CBMinorantPointer,Nothing} = nothing, delta_index::Union{<:CBIndexmatrix,Nothing} = nothing, relprec::Real = 1e-2)

• @brief for a given model aggregate compute the groundset aggregate and the resulting (feasible) candidate

  Let \f$ (\sigma,s) \f$ be the aggregate minorant \f$\sigma+s^\top y\le f(y)\f$ of the cost function described by @a modelsubgoffset and @a modelsubg, let \f$\hat y\f$ be the center of stability given by @a centery, let \f$H\f$ denote the positive definite scaling matrix with weight \f$u\f$ given by @a Hp, let \f$Y\f$ denote this (convex) feasible ground set and \f$i_Y\f$ its indicator function, then this computes a saddle point \f$(y,(\gamma,g))\f$ of

  \f[ \max{(\gamma,g)\in\partial iY}\min{y\in\mathbf{R}^n} [(s+g)^\top y + \gamma+\sigma +\frac{u}2\|y-\hat y\|H^2],\f]

  The resulting \f$y\f$ is feasible and stored in @a newy. @a linval gets \f$\gamma+\sigma+(g+s)^\top y\f$, @a subgnorm2 gets \f$u\|y-\hat x\|_H^2\f$, @a augval gets @a linval+@a subgnorm2 /2.

  If @a deltagroundsetsubg is not NULL, also @a eltagroundsetsubgoffset and @a delta index are assumed to be not NULL. Then all changes from the previous groundset aggregate minorant to the new groundset aggregate minorant \f$(\gamma,g)\f$ are stored in @a deltagroundsetsubgoffset and @a deltagroundsetsubg and @a deltaindex holds the indices of the nonzero changes (mostly the groundset aggregate is sparse, e.g. due to complementarity). This is used in BundleProxObject::updateQP_costs().

  On input \f$\varepsilon=\f$ @a relprec, \f$\bar f=\f$ @a center_value, and \f$\underline{f}=\f$ @a augval serve to form appropriate stopping criteria if solving the saddle point problem requires a nonlinear convex optimization method. The method is then assumed to produce a primal solution \f$y\in Y\f$ of value \f$\bar s\f$ and a dual solution \f$(\gamma,g)\f$ of value \f$\underline{g}\f$ with the properties \f$\underline g-\underline f\ge 0\f$ and \f$\bar f-\bar s\ge 0\f$ and \f$\bar s-\underline{g}\le\varepsilon(|\bar s|+1.)\f$. In particular \f$y\in Y\f$ is assumed to hold to machine precision.

  If useyfixing is true (the fixing heuristic is switched on), then \fyi=\hat yi\f$ is required to hold for all i with yfixed(i)!=0, so these coordinates are not allowed to change. In particular, this routine may also set yfixed(i)=2 for new coordinates i, where 2 is used to indicate newly fixed variables. These will be reset to 1 in BundlesScaling::computeQPcosts() and BundlesScaling::updateQP_costs() when this information has been digested.

  In some derived classes a scaling heuristic is called that may influence the scaling @a Hp so as to avoid going outside the feasible region too far.

  @param[out] gsid the current groundsetid

  @param[out] newy the next candidate y (feasible)

  @param[out] candgsval the value of the groundset minorant in the candidate y (=groundset objective)

  @param[out] linval (CHMatrixClasses::Real&) value of linear minorant in y

  @param[in,out] augvallb (CHMatrix_Classes::Real&) - on input: lower bound value of augmented model in previous (maybe infeasible) candidate - on output: lower bound value of augmented model in y

  @param[out] augvalub (CHMatrix_Classes::Real&) - on output: upper bound value of augmented model in y

  @param[out] subgnorm2 (CHMatrixClasses::Real&) squared Hp-norm (with weight) of joint groundset and model aggregate

  @param[in] centery (const CHMatrix_Classes::Matrix&) center of stability (feasible)

  @param[in] centervalue (CHMatrixClasses::Real) function value in centery

  @param[in] model_minorant (const MinorantPoiner&) aggregate linear minorant of the cost function

  @param[in,out] Hp (ConicBundle::BundleProxObject*) pointer to scaling matrix H, may be influenced by a scaling heuristic

  @param[in,out] deltagroundsetminorant (MinorantPointer*) if not NULL, the change in groundset aggregate will be stored here

  @param[in,out] deltaindex (CHMatrixClasses::Indexmatrix*) must be not NULL iff deltagroundsetsubg!=NULL or yfixed has changed, will store nonzero indices of deltagroundset_subg

  @param[in] relprec (CHMatrixClasses::Real) relative precision for termination in QP computations

  @return 0 on success, != 0 on failure

cb_ceil(A::CBMatrix)

returns a matrix with elements (i,j)=ceil((*this)(i,j)) for all i,j

cb_ceil!(self::CBMatrix)

sets (this)(i,j)=ceil((this)(i,j)) for all i,j and returns *this

cb_center_modified!(self::CBAFTData, center_id::Integer)

check whether center computation is still valid for this point and modification id

cb_center_modified!(self::CBAFTModel, center_id::Integer)

see BundleModel::center_modified

cb_center_modified!(self::CBSumModel, center_id::Integer)

see BundleModel::center_modified

cb_check_center_validity_by_candidate!(self::CBAFTModel, cand_minorant_is_below::Bool, center_id::Integer, center_y::CBMatrix)

see BundleModel::checkcentervaliditybycandidate

cb_check_center_validity_by_candidate!(self::CBSumModel, cand_minorant_is_below::Bool, center_id::Integer, center_y::CBMatrix)

see BundleModel::checkcentervaliditybycandidate

cb_check_correctness(self::CBBoxOracle)

*@brief switch on/off some correctnes checks on the oracle

cb_check_correctness(self::CBNNCBoxSupportFunction)

see MatrixFunctionOracle::check_correctness() (true only needed for debugging)

cb_check_correctness(self::CBPSCAffineFunction)

see PSCOracle::check_correctness()

cb_check_correctness(self::CBSOCSupportFunction)

see SOCOracle::check_correctness() (true only needed for debugging)

cb_check_support(self::CBSparsesym, i::Integer, j::Integer)

returns 0 if (i,j) is not in the support, 1 otherwise

cb_clear!(self::CBAFTData, start_modification_id::Integer = 0)

reset to initial state (also used by the default constructor)

cb_clear!(self::CBAFTModel)

overloads the SumBlockModel::clear calling the other clear with parameter 0

cb_clear!(self::CBAFTModel, inaft::Union{<:CBAffineFunctionTransformation,Nothing}, start_modification_id::Integer = 0)

resets all data to the inital state, except for aft which is unchanged unless @a inaft ist not NULL, which then replaces aft

cb_clear!(self::CBAFTModification, var_olddim::Integer, row_olddim::Integer)

reset modifications to an unmodified object currently having varolddim columns and rowolddim rows, calls Modification::clear

cb_clear!(self::CBBoxData, start_modification_id::Integer = 0)

reset to initial state (also used by the default constructor)

cb_clear!(self::CBBoxModel)

resets all data to initial status of this class, also the bundle parameters

cb_clear!(self::CBBundleHKWeight)

reset all adaptive variables and parameters

cb_clear!(self::CBBundleRQBWeight)

reset all adaptive variables and parameters

cb_clear!(self::CBBundleSolver)

resets all variables and pointers to classes to initial state and calls set_defaults()

cb_clear!(self::CBBundleTerminator)

resets @a terminated

cb_clear!(self::CBGroundsetModification, var_olddim::Integer)

reset modifications to an unmodified object currently having var_olddim variables, calls Modification::clear

cb_clear!(self::CBLPGroundset, indim::Integer = 0, in_groundset_id::Integer = 0)

resets all values as described in Groundset::clear()

cb_clear!(self::CBMatrixCBSolver)

• @brief Clears all data structures and problem information but keeps ouptut settings and algorithmic parameter settings

cb_clear!(self::CBMinorantPointer)

afterwards the pointer is empty (calls delete_data())

cb_clear!(self::CBNNCBoxSupportModification, var_olddim::Integer)

reset modifications to an unmodified object currently having var_olddim variables, calls Modification::clear

cb_clear!(self::CBNNCData, start_modification_id::Integer = 0)

reset to initial state (also used by the default constructor)

cb_clear!(self::CBNNCModel)

resets all data to initial status of this class, also the bundle parameters

cb_clear!(self::CBPSCAffineModification, var_olddim::Integer, block_olddim::CBIndexmatrix)

• @brief resets all variables so that the object to be modified has starting size varolddim (number of variables) and blockolddim (number of rows) and no modifications

    The actual old data is not needed at this point,
    the changes on it will be collected and excuted in the
    routines apply_to_vars and apply_to_blocks
  
    Setting the parameter ensure_start_val_box_feasibility to true
    will cause the algorithm to check in add_append_vars() whether
    the input values are within the given bounds and in
    apply_to_vars() it will project all start_values onto the bounds
    for all, old and new, indices (which might have been changed by
    then).  If it is false (default), all values will be accepted as
    given.
  
    Setting the parameter ensure_bounds_consistency to true
    (default) will raise errors in add_append_vars() and in
    apply_to_vars() whenever there are lower bounds greater than the
    respective upper bounds so as to avoid trivial
    infeasibilities. This check is omitted if set to false.
  
    The remaining values give the values of plus and minus infinity
    the no bounds should exceed. These are the default values at the
    same time (maybe it might be good to have a separate default value,
    but this is not implemented here).

cb_clear!(self::CBPSCData, start_modification_id::Integer = 0)

reset to initial state (also used by the default constructor)

cb_clear!(self::CBPSCModel)

resets all data to initial status of this class, also the bundle parameters

cb_clear!(self::CBQPConeModelBlock)

reset to "empty/no" model

cb_clear!(self::CBQPDirectKKTSolver)

reset data to empty

cb_clear!(self::CBQPKKTSolverComparison)

reset data to empty

cb_clear!(self::CBQPSumModelBlock)

reset to "empty/no" model

cb_clear!(self::CBSOCData, start_modification_id::Integer = 0)

reset to initial state (also used by the default constructor)

cb_clear!(self::CBSOCModel)

resets all data to initial status of this class, also the bundle parameters

cb_clear!(self::CBSOCSupportModification, var_olddim::Integer)

reset modifications to an unmodified object currently having var_olddim variables, calls Modification::clear

cb_clear!(self::CBSparseCoeffmatMatrix)

clears all (empty 0 times 0 matrix)

cb_clear!(self::CBSumModel)

resets the SumModel to its initial state, in particular it removes but does not delete any Models added in add_model() (their AFTs are deleted if not explicitly denied)

cb_clear!(self::CBUQPConeModelBlock)

reinitialize to "empty/no" model

cb_clear!(self::CBUQPSolver)

reset to "empty/no" model

cb_clear!(self::CBUQPSumModelBlock)

reset to "empty/no" model

cb_clear!(self::CBUnconstrainedGroundset, indim::Integer = 0, in_groundset_id::Integer = 0)

• @brief reset everything to initial state for an unconstrained ground set of dimension @a indim

    Note that a ground set is allowed to have dimension zero. This
    will lead to evaluating a function without arguments and is
    a realistic scenario in Lagrangean relaxation of cutting plane
    approaches if no cutting planes have been added yet.
  
    If the changes to the ground set are to be counted by groundset_id,
    then it makes sense to enter the appropriate value in in_groundset_id.

cb_clear_aggregates!(self::CBMatrixCBSolver, function_::Union{<:CBFunctionObject,Nothing} = nothing)

• @brief Clears the aggregate parts of the cutting model of this @a function (but only for the given one, not recursively)

   There should be no need to call this if the modification
   routines of this interface were used correctly. If, however,
   the oracle is modified by other means outside this interface,
   this has to be called whenever the specified function was
   modified so that the old aggregate subgradients and/or primal
   generators are no longer valid.
  
  @param[in] function (const FunctionObject&)
    the function added in add_function()
  
  @return
    - 0 on success
    - != 0 otherwise

cb_clear_aggregates!(self::CBAFTData)

delete all kinds of aggregates but keep explicit parts of the cutting model

cb_clear_aggregates!(self::CBBoxData)

remove all aggregate minorants

cb_clear_aggregates!(self::CBNNCData)

remove all aggregate minorants

cb_clear_aggregates!(self::CBPSCData)

delete all kinds of aggregates but keep explicit parts of the cutting model

cb_clear_aggregates!(self::CBSOCData)

delete all kinds of aggregates but keep explicit parts of the cutting model

cb_clear_aggregates!(self::CBAFTModel)

see SumBlockModel::clear_aggregates

cb_clear_aggregates!(self::CBSumModel)

see SumBlockModel::clear_aggregates

cb_clear_aggregates!(self::CBSumBundleHandler)

first calls remove_contributions(), then discards all aggregate minorants in the current model

cb_clear_cand_minorants!(self::CBSumBundleHandler)

before contributing the new evaluation results, the candidates have to be cleared

cb_clear_fail_counts!(self::CBMatrixCBSolver)

• @brief clears all fail counts on numerical function oder model failures, may be useful if this caused premature termination.

  @return
    - 0 on success
    - != 0 otherwise

cb_clear_fails!(self::CBBundleSolver)

resets all fail counts to zero (call this to resume computations

cb_clear_model!(self::CBAFTData, discard_minorants_only::Bool = false)

clear the cutting modle and all function evaluatoins

cb_clear_model!(self::CBBoxData, discard_minorants_only::Bool = false)

clear the cutting model and all function evaluations

cb_clear_model!(self::CBNNCData, discard_minorants_only::Bool = false)

clear the cutting model and all function evaluations

cb_clear_model!(self::CBPSCData, discard_minorants_only::Bool = false)

clear the cutting model and all function evaluations

cb_clear_model!(self::CBSOCData, discard_minorants_only::Bool = false)

clear the cutting model and all function evaluations

cb_clear_model!(self::CBAFTModel, discard_minorants_only::Bool = false)

see SumBlockModel::clear_model

cb_clear_model!(self::CBSumModel, discard_minorants_only::Bool = false)

see SumBlockModel::clear_model

cb_clear_model!(self::CBSumBundleHandler)

first calls remove_contributions(), then discards all current models

cb_clear_terminated!(self::CBBundleTerminator)

reset the termination code to zero (this does not remove the reason for the termination; for this, set other bounds or clear the numbers supplied by BundleTerminationData)

cb_clone(self::CBCMgramdense)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCMgramsparse)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCMgramsparse_withoutdiag)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCMlowrankdd)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCMlowranksd)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCMlowrankss)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCMsingleton)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCMsymdense)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCMsymsparse)

makes an explicit copy of itself and returns a pointer to it

cb_clone(self::CBCoeffmatInfo)

generates a new copy of itself on the heap

cb_clone(self::CBAFTData)

return a pointer to a clone of this

cb_clone(self::CBBoxData)

return a pointer to a clone of this

cb_clone(self::CBNNCData)

return a pointer to a clone of this

cb_clone(self::CBPSCData)

return a pointer to a clone of this

cb_clone(self::CBSOCData)

return a pointer to a clone of this

cb_clone!(self::CBQPConeModelBlock)

return a cloned object on the heap

cb_clone!(self::CBQPSumModelBlock)

return a cloned object on the heap

cb_clone_BundleParameters(self::CBBoxModelParameters)

clone

cb_clone_BundleParameters(self::CBNNCModelParameters)

clone

cb_clone_BundleParameters(self::CBPSCModelParameters)

clone

cb_clone_BundleParameters(self::CBSOCModelParameters)

clone

cb_clone_BundleParameters(self::CBSumBundleParameters)

clone

cb_clone_VariableMetricSelection!(self::CBPSCVariableMetricSelection)

clone: the values are only preserved for those contained in the constructor: nlatestminorants, selection_method and oldfactor

cb_clone_VariableMetricSelection!(self::CBVariableMetricSVDSelection)

clone: the values are only preserved for those contained in the constructor: nlatestminorants, selection_method and oldfactor

cb_clone_minorant(self::CBMinorant, factor::Real = 1., with_primal::Bool = true)

generates a full copy (multiplied by factor) on the heap and returns a pointer to it (it also includes a clone of the primal data if with_primal==true, otherwise the copy will have no primal data)

cb_coeff(self::CBMinorantPointer, i::Integer)

returns coefficient i of the minorant (including the internal scalings) or 0. if empty

cb_coeff(self::CBMinorantUseData, i::Integer)

return coefficient @a i of the minorant

cb_coeff!(self::CBMinorant, i::Integer)

returns the value of the coefficient in coordinate i

cb_col(self::CBMatrix, i::Integer)

returns column i copied to a new matrix

cb_col(self::CBIndexmatrix, i::Integer)

returns column i copied to a new matrix

cb_col(self::CBSparsemat, i::Integer)

returns column i copied to a new sparse matrix

cb_col(self::CBSymmatrix, i::Integer)

returns column i copied to a new Matrix

cb_col_nonzeros(self::CBSparsemat, i::Integer, startind::Union{<:AbstractVector{Cint},Nothing} = nothing)

returns the number of nonzeros in column i; if nonzeros>0 and startind!=0 then the index of the first nonzero in colindex/colval is stored there

cb_coldim(self::CBMatrix)

returns the column dimension

cb_coldim(self::CBIndexmatrix)

returns the column dimension

cb_coldim(self::CBSparsemat)

returns the column dimension

cb_coldim(self::CBSymmatrix)

returns the column dimension

cb_coldim(self::CBSparsesym)

returns the column dimension

cb_coldim(self::CBSparseCoeffmatMatrix)

returns the number of columns (i.e. of blockdiagonal matrices)

cb_colhouse(A::CBMatrix, v::CBMatrix, i::Integer, j::Integer)

Housholder post-multiplication of A with Householder vector v; the first nonzero of v is index i, the multplication is applied to all rows of A with index >=j; always returns 0

cb_colip(A::CBMatrix, j::Integer, scaling::Union{<:CBMatrix,Nothing})

returns the squared Frobenius norm of column j of A, i.e., the sum of A(i,j)A(i,j) over all i with possibly (if scaling!=0) each term i multiplied by (scaling)(i)

cb_colip(A::CBSparsemat, j::Integer, scaling::Union{<:CBMatrix,Nothing})

returns the squared Frobenius norm of col i of A, i.e., the sum of A(i,j)A(i,j) over all i with possibly (if scaling!=0) each term i multiplied by (scaling)(i)

cb_cols(self::CBMatrix, vec::CBIndexmatrix)

returns a matrix of size this->rowdim() x vec.dim(), with column i a copy of column vec(i) of *this

cb_cols(self::CBIndexmatrix, vec::CBIndexmatrix)

returns a matrix of size this->rowdim() x vec.dim(), with column i a copy of column vec(i) of *this

cb_cols(self::CBSparsemat, ind::CBIndexmatrix)

returns a sparse matrix of size this->rowdim() x vec.dim(), with column i a copy of column vec(i) of *this

cb_cols(self::CBSymmatrix, vec::CBIndexmatrix)

returns a matrix of size this->rowdim() x vec.dim(), with column i a copy of column vec(i) of *this

cb_colsip(A::CBMatrix)

returns the column vector of the squared Frobenius norm of all columns j of A, i.e., the sum of A(i,j)*A(i,j) over all i for each j

cb_colsip(A::CBSparsemat, scaling::Union{<:CBMatrix,Nothing})

returns the column vector of the squared Frobenius norm of all columns j of A, i.e., the sum of A(i,j)A(i,j) over all i for each j with possibly (if scaling~=0) each term i multiplied by (scaling)(i)

cb_compute!(self::CBMinRes, system::CBIterativeSystemObject, x::CBMatrix, termprec::Real, storex::Union{<:CBMatrix,Nothing} = nothing, storestep::Integer = 0)

compute the solution for system into x with (absolute) residual precision termprec

cb_compute!(self::CBPCG, system::CBIterativeSystemObject, x::CBMatrix, termprec::Real, storex::Union{<:CBMatrix,Nothing} = nothing, storestep::Integer = 0)

compute the solution for system into x with (absolute) residual precision termprec

cb_compute!(self::CBPsqmr, system::CBIterativeSystemObject, x::CBMatrix, termprec::Real, storex::Union{<:CBMatrix,Nothing} = nothing, storestep::Integer = 0)

compute the solution for system into x with (absolute) residual precision termprec

cb_compute_QP_costs!(self::CBBundleDenseTrustRegionProx, Q::CBSymmatrix, d::CBMatrix, constant_minorant::CBMinorantPointer, bundle::CBMinorantBundle, y::CBMatrix, groundset_minorant::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing})

computes the dual QP costs Q, d, and the constant offset to the bundle subproblem, see BundleProxObject::computeQPcosts

cb_compute_QP_costs!(self::CBBundleDiagonalTrustRegionProx, Q::CBSymmatrix, d::CBMatrix, constant_minorant::CBMinorantPointer, bundle::CBMinorantBundle, y::CBMatrix, groundset_minorant::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing})

computes the dual QP costs Q, d, and the constant offset to the bundle subproblem, see BundleProxObject::computeQPcosts

cb_compute_QP_costs!(self::CBBundleDLRTrustRegionProx, Q::CBSymmatrix, d::CBMatrix, constant_minorant::CBMinorantPointer, bundle::CBMinorantBundle, y::CBMatrix, groundset_minorant::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing})

computes the dual QP costs Q, d, and the constant offset to the bundle subproblem, see BundleProxObject::computeQPcosts

cb_compute_QP_costs!(self::CBBundleIdProx, Q::CBSymmatrix, d::CBMatrix, constant_minorant::CBMinorantPointer, bundle::CBMinorantBundle, y::CBMatrix, groundset_minorant::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing})

computes the dual QP costs Q, d, and the constant offset to the bundle subproblem, see BundleProxObject::computeQPcosts

cb_compute_QP_costs!(self::CBBundleLowRankTrustRegionProx, Q::CBSymmatrix, d::CBMatrix, constant_minorant::CBMinorantPointer, bundle::CBMinorantBundle, y::CBMatrix, groundset_minorant::CBMinorantPointer, yfixed::Union{<:CBIndexmatrix,Nothing})

computes the dual QP costs Q, d, and the constant offset to the bundle subproblem, see BundleProxObject::computeQPcosts

cb_compute_local_directions!(self::CBUQPConeModelBlock, qp_dx::CBMatrix, qp_dy::CBMatrix, rhs_resid::CBMatrix, dz::CBMatrix, duz::CBMatrix)

given the steps of the global part, compute the step of the local part

cb_compute_step!(self::CBQPConeModelBlock, ystep::CBMatrix, global_bundle::CBMinorantBundle, startindex_bundle::Integer)

compute the step in the model space given the step in the design space

cb_compute_step!(self::CBQPSumModelBlock, ystep::CBMatrix, global_bundle::CBMinorantBundle, startindex_bundle::Integer)

compute the step in the model space given the step in the design space

cb_computed_Schur_step!(self::CBQPConeModelBlock, xstep::CBMatrix, local_step::CBMatrix, startindex_model::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

use the computed step information to also compute the steps of the complemented parts

cb_computed_Schur_step!(self::CBQPSumModelBlock, xstep::CBMatrix, local_step::CBMatrix, startindex_model::Integer, globalbundle::CBMinorantBundle, startindex_bundle::Integer)

for passing on the solution information after solvin the system

cb_computed_step!(self::CBQPConeModelBlock, modelxstep::CBMatrix, startindex_model::Integer, modelconstrstep::CBMatrix, startindex_constr::Integer)

store this computed step locally and compute the missing local dual step information

cb_computed_step!(self::CBQPSumModelBlock, modelxstep::CBMatrix, startindex_model::Integer, modelconstrstep::CBMatrix, startindex_constr::Integer)

store this computed step locally and compute the missing local dual step information

cb_concat_below(A::CBMatrix, B::CBMatrix)

returns a bew matrix [A; B], i.e., it concats matrices A and B columnwise; A or B may be a 0x0 matrix

cb_concat_below(A::CBIndexmatrix, B::CBIndexmatrix)

returns the matrix [A; B], i.e., it concats matrices A and B columnwise; A or B may be a 0x0 matrix

cb_concat_below(A::CBSparsemat, B::CBSparsemat)

returns a new sparse matrix [A; B], i.e., it concats matrices A and B columnwise; A or B may be a 0x0 matrix

cb_concat_below!(self::CBMatrix, A::CBMatrix)

concats matrix A to the bottom of *this, A or *this may be the 0x0 matrix initally, returns *this

cb_concat_below!(self::CBMatrix, d::Real)

concat value d at the right of *this, *this must be a row vector or the 0x0 matrix, returns *this

cb_concat_below!(self::CBIndexmatrix, A::CBIndexmatrix)

concats matrix A to the bottom of *this, A or *this may be the 0x0 matrix initally, returns *this

cb_concat_below!(self::CBIndexmatrix, d::Integer)

concat value d at the bottom of *this, *this must be a column vector or the 0x0 matrix, returns *this

cb_concat_below!(self::CBSparsemat, A::CBSparsemat)

concats sparse matrix A to the bottom of *this, A or *this may be the 0x0 matrix initally, returns *this

cb_concat_right(A::CBMatrix, B::CBMatrix)

returns a new matrix [A, B], i.e., it concats matrices A and B rowwise; A or B may be a 0x0 matrix

cb_concat_right(A::CBIndexmatrix, B::CBIndexmatrix)

returns a new matrix [A, B], i.e., it concats matrices A and B rowwise; A or B may be a 0x0 matrix

cb_concat_right(A::CBSparsemat, B::CBSparsemat)

returns a new sparse matrix [A, B], i.e., it concats matrices A and B rowwise; A or B may be a 0x0 matrix

cb_concat_right!(self::CBMatrix, A::CBMatrix, Atrans::Integer = 0)

concats matrix A (or its tranpose) to the right of *this, A or *this may be the 0x0 matrix initally, returns *this

cb_concat_right!(self::CBMatrix, d::Real)

concat value d at the bottom of *this, *this must be a column vector or the 0x0 matrix, returns *this

cb_concat_right!(self::CBIndexmatrix, A::CBIndexmatrix)

concats matrix A to the right of *this, A or *this may be the 0x0 matrix initally, returns *this

cb_concat_right!(self::CBIndexmatrix, d::Integer)

concat value d at the right of *this, *this must be a row vector or the 0x0 matrix, returns *this

cb_concat_right!(self::CBSparsemat, A::CBSparsemat)

concats sparse matrix A to the right of *this, A or *this may be the 0x0 matrix initally, returns *this

cb_cond_number_mult!(self::CBQPKKTSubspaceHPrecond, vec::CBMatrix, KKTdiagx::CBMatrix, KKTdiagy::CBMatrix)

for estimating the condition number directly for the preconditioned part only

cb_constrained(self::CBLPGroundset)

returns false if the feasible set is the entire space (unconstrained optimization), true otherwise.

cb_constrained(self::CBUnconstrainedGroundset)

• @brief returns false if the feasible set is the entire space (unconstrained optimization), true otherwise.

    The current class implements the unconstrained case and always returns false.

cb_constraints_cost!(self::CBQPConeModelBlock)

returns the dual upper bound to the model value (the trace weighted sum of the dual trace variables); it returns 0. if no model is contained

cb_constraints_cost!(self::CBQPSumModelBlock)

returns the dual upper bound to the model value (the trace weighted sum of the dual trace variables); it returns 0. if no model is contained

cb_contains_nan!(self::CBMatrix)

returns true if any matrix element returns true on std::isnan

cb_contains_support(self::CBSparsemat, A::CBSparsemat)

returns 1 if A is of the same dimension and the support of A is contained in the support of *this, 0 otherwise

cb_contains_support(self::CBSparsesym, A::CBSparsesym)

returns 1 if A is of the same dimension and the support of A is contained in the support of *this, 0 otherwise

cb_contribute_initial_bundle!(self::CBSumBundleHandler, ft::CBFunctionTask, bundle_minorants::CBMinorantBundle, coeff::CBMatrix)

• @brief (re)initialize the bundle of the respective part

   This is only possible, if the handler handles a bundle for this.
   If not this causes an error. The main purpose is really
   to start the bundle on the fly if a parent starts a sumbundle
   in the middle of the computation. The information in coeff
   is assumed to yield the current aggregate.
  
   If this bundle part has been contributed berfore (its mode is child), the
   contribution is first removed from the parent. Then any existing
   information except for the function factor is discarded and replaced by
   the new bundle information with the number of contributions set to 1.
  
   If the size of primals is not zero, it must have one nonzero entry per
   column of minorants and all future calls via set_cand_minorant() also have
   to provide exactly one primal for each update.

cb_contribute_new_minorants!(self::CBSumBundleHandler)

once all new minorants have been collected at this level, they are passed to the next if required

cb_copy_traforows(self::CBAffineFunctionTransformation, copy_to::CBMatrix, copy_from::CBMatrix)

only copies the elements that are effected by the image of arg_trafo

cb_delete_blocks!(self::CBSparseCoeffmatMatrix, delete_indices::CBIndexmatrix, map_to_old::Union{<:CBIndexmatrix,Nothing} = nothing)

generates a maptoold by deleting the specified indices and calls reassignblocks; this mapto_old will be returned if the corresponding pointer is not NULL

cb_delete_cols!(self::CBMatrix, ind::CBIndexmatrix, sorted_increasingly::Bool = false)

all colmuns indexed by vector ind are deleted, no column should appear twice in ind, remaining columns are moved left keeping their order, returns *this

cb_delete_cols!(self::CBIndexmatrix, ind::CBIndexmatrix, sorted_increasingly::Bool = false)

all colmuns indexed by vector ind are deleted, no column should appear twice in ind, remaining columns are moved up keeping their order, returns *this

cb_delete_cols!(self::CBSparsemat, ind::CBIndexmatrix)

all colmuns indexed by vector ind are deleted, no column should appear twice in ind, remaining columns are moved up keeping their order, returns *this

cb_delete_columns!(self::CBSparseCoeffmatMatrix, delete_indices::CBIndexmatrix, map_to_old::Union{<:CBIndexmatrix,Nothing} = nothing)

generates a maptoold by deleting the specified indices and calls reassigncolumns; this mapto_old will be returned if the corresponding pointer is not NULL

cb_delete_principal_submatrix!(self::CBSymmatrix, ind::CBIndexmatrix, sorted_increasingly::Bool = false)

returns this afte deleting the principal submatrix indexed by ind (no repetitions!);

cb_delete_rows!(self::CBMatrix, ind::CBIndexmatrix, sorted_increasingly::Bool = false)

all rows indexed by vector ind are deleted, no row should appear twice in ind, remaining rows are moved up keeping their order, returns *this

cb_delete_rows!(self::CBIndexmatrix, ind::CBIndexmatrix, sorted_increasingly::Bool = false)

all rows indexed by vector ind are deleted, no row should appear twice in ind, remaining rows are moved up keeping their order, returns *this

cb_delete_rows!(self::CBSparsemat, ind::CBIndexmatrix)

all rows indexed by vector ind are deleted, no row should appear twice in ind, remaining rows are moved up keeping their order, returns *this

cb_delete_variables!(self::CBMatrixCBSolver, delete_indices::CBIndexmatrix, map_to_old::CBIndexmatrix)

• @brief Deletes variables corresponding to the specified indices.

    The indices of the remaining variables are reassigned so that they
    are consecutive again, the routine returns in @a map_to_old
    a vector giving for each new index of these remaining variables
    the old coordinate.

  @attention Be sure to include a desription of required changes to your functions via @a affectedfunctionswith_modifications

  @param[in] deleteindices (const Indexmatrix&) the entries deleteindices[i] specify the indices of the variables to be deleted

  @param[out] maptoold (Indexmatrix&) after the call, element maptoold[i] gives the old index (before the call) of the variable that now has index position i.

  @param[in] affectedfunctionswith_modifications (const FunObjModMap*) If NULL, default actions are performed on all functions. In particular, for those admitting dynamic argument changes all those variables will be deleted whose row in a corresponding updated affine function transformation (so after deletion of the columns of the incoming variables) corresponds to the zero map (i.e., offset and matrix row are both zero), furthermore identity transformations will be preserved. For those not admitting changes in their arguments, their corresponding (possibly newly created) affine function transformation will only get the columns deleted, but there will be no row deleltions. If !=NULL, for the listed functions (and their parents up to the root function) the default deletion action is performed unless their FunctionObjectModification entry gives explicit modification instructions which are then applied instead. For all functions NOT listed in the map and not having modified offsprings their corresponding aft will be set up to keep the arguments unchanged.

  @return - 0 on success - != 0 otherwise

cb_deleted_block_indices(self::CBPSCAffineModification)

returns null if there were no deletions, otherwise the Indexmatrix pointed to is a vector holding the deleted old row indices in increasing order

cb_deleted_row_indices(self::CBAFTModification)

returns null if there were no deletions, otherwise the Indexmatrix pointed to is a vector holding the deleted old row indices in increasing order

cb_deleted_var_indices(self::CBAFTModification)

returns null if there were no deletions, otherwise the Indexmatrix pointed to is a vector holding the deleted old variable indices in increasing order

cb_deleted_var_indices(self::CBGroundsetModification)

returns null if there were no deletions, otherwise the Indexmatrix pointed to is a vector holding the deleted old variable indices in increasing order

cb_deleted_var_indices(self::CBNNCBoxSupportModification)

returns null if there were no deletions, otherwise the Indexmatrix pointed to is a vector holding the deleted old variable indices in increasing order

cb_deleted_var_indices(self::CBPSCAffineModification)

returns null if there were no deletions, otherwise the Indexmatrix pointed to is a vector holding the deleted old variable indices in increasing order

cb_deleted_var_indices(self::CBSOCSupportModification)

returns null if there were no deletions, otherwise the Indexmatrix pointed to is a vector holding the deleted old variable indices in increasing order

cb_deleted_variables_are_zero(self::CBAFTModification, oldpoint::CBMatrix)

returns true if all entries deleted in @a oldpoint (must be a vector of length old_vardim()) are 0, false otherwise

cb_deleted_variables_are_zero(self::CBGroundsetModification, oldpoint::CBMatrix)

returns true if all entries deleted in @a oldpoint (must be a vector of length old_vardim()) are 0, false otherwise

cb_deleted_variables_are_zero(self::CBNNCBoxSupportModification, oldpoint::CBMatrix)

returns true if all entries deleted in @a oldpoint (must be a vector of length old_vardim()) are 0, false otherwise

cb_deleted_variables_are_zero(self::CBPSCAffineModification, oldpoint::CBMatrix, oldmat::CBSparseCoeffmatMatrix)

returns true if all entries deleted in @a oldpoint (must be a vector of length old_vardim()) or the corresponding entries in the old matrix are 0 and false otherwise

cb_deleted_variables_are_zero(self::CBSOCSupportModification, oldpoint::CBMatrix)

returns true if all entries deleted in @a oldpoint (must be a vector of length old_vardim()) are 0, false otherwise

cb_dense(self::CBCMgramdense)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_dense(self::CBCMgramsparse)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_dense(self::CBCMgramsparse_withoutdiag)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_dense(self::CBCMlowrankdd)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_dense(self::CBCMlowranksd)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_dense(self::CBCMlowrankss)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_dense(self::CBCMsingleton)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_dense(self::CBCMsymdense)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_dense(self::CBCMsymsparse)

returns 1 if its structure is as bad as its dense symmetric representation, otherwise 0

cb_descent_update!(self::CBBundleHKWeight, newval::Real, oldval::Real, modelval::Real, y::CBMatrix, newy::CBMatrix, normsubg2::Real, Hp::Union{<:CBBundleProxObject,Nothing})

determine next weight after a descent step

cb_descent_update!(self::CBBundleRQBWeight, newval::Real, oldval::Real, modelval::Real, y::CBMatrix, newy::CBMatrix, normsubg2::Real, Hp::Union{<:CBBundleProxObject,Nothing})

determine next weight after a descent step

cb_destroy!(obj::CBMatrix)

cb_destroy!(obj::CBIndexmatrix)

cb_destroy!(obj::CBSparsemat)

cb_destroy!(obj::CBSymmatrix)

cb_destroy!(obj::CBSparsesym)

cb_destroy!(obj::CBCMgramdense)

cb_destroy!(obj::CBCMgramsparse)

cb_destroy!(obj::CBCMgramsparse_withoutdiag)

cb_destroy!(obj::CBCMlowrankdd)

cb_destroy!(obj::CBCMlowranksd)

cb_destroy!(obj::CBCMlowrankss)

cb_destroy!(obj::CBCMsingleton)

cb_destroy!(obj::CBCMsymdense)

cb_destroy!(obj::CBCMsymsparse)

cb_destroy!(obj::CBSparseCoeffmatMatrix)

cb_destroy!(obj::CBGB_rand)

cb_destroy!(obj::CBCoeffmatInfo)

cb_destroy!(obj::CBPrimalMatrix)

cb_destroy!(obj::CBMatrixCBSolver)

cb_destroy!(obj::CBBlockPSCPrimal)

cb_destroy!(obj::CBDensePSCPrimal)

cb_destroy!(obj::CBGramSparsePSCPrimal)

cb_destroy!(obj::CBSparsePSCPrimal)

cb_destroy!(obj::CBAFTModification)

cb_destroy!(obj::CBGroundsetModification)

cb_destroy!(obj::CBNNCBoxSupportModification)

cb_destroy!(obj::CBPSCAffineModification)

cb_destroy!(obj::CBSOCSupportModification)

cb_destroy!(obj::CBAffineFunctionTransformation)

cb_destroy!(obj::CBMinorantPointer)

cb_destroy!(obj::CBMinorantUseData)

cb_destroy!(obj::CBMinorant)

cb_destroy!(obj::CBBoxPrimalExtender)

cb_destroy!(obj::CBBoxOracle)

cb_destroy!(obj::CBPSCPrimalExtender)

cb_destroy!(obj::CBPSCBundleParameters)

cb_destroy!(obj::CBSOCPrimalExtender)

cb_destroy!(obj::CBSOCBundleParameters)

cb_destroy!(obj::CBCFunctionMinorantExtender)

cb_destroy!(obj::CBCFunction)

cb_destroy!(obj::CBNNCBoxSupportMinorantExtender)

cb_destroy!(obj::CBNNCBoxSupportFunction)

cb_destroy!(obj::CBPSCAffineMinorantExtender)

cb_destroy!(obj::CBPSCAffineFunction)

cb_destroy!(obj::CBSOCSupportMinorantExtender)

cb_destroy!(obj::CBSOCSupportFunction)

cb_destroy!(obj::CBBoxModelParameters)

cb_destroy!(obj::CBNNCModelParameters)

cb_destroy!(obj::CBPSCModelParameters)

cb_destroy!(obj::CBSOCModelParameters)

cb_destroy!(obj::CBSumBundleParameters)

cb_destroy!(obj::CBAFTData)

cb_destroy!(obj::CBBoxData)

cb_destroy!(obj::CBNNCData)

cb_destroy!(obj::CBPSCData)

cb_destroy!(obj::CBSOCData)

cb_destroy!(obj::CBBundleHKWeight)

cb_destroy!(obj::CBBundleRQBWeight)

cb_destroy!(obj::CBBundleDenseTrustRegionProx)

cb_destroy!(obj::CBBundleDiagonalTrustRegionProx)

cb_destroy!(obj::CBBundleDLRTrustRegionProx)

cb_destroy!(obj::CBBundleIdProx)

cb_destroy!(obj::CBBundleLowRankTrustRegionProx)

cb_destroy!(obj::CBQPSolverParameters)

cb_destroy!(obj::CBQPSolver)

cb_destroy!(obj::CBUQPSolver)

cb_destroy!(obj::CBLPGroundset)

cb_destroy!(obj::CBUnconstrainedGroundset)

cb_destroy!(obj::CBAFTModel)

cb_destroy!(obj::CBBoxModel)

cb_destroy!(obj::CBNNCModel)

cb_destroy!(obj::CBPSCModel)

cb_destroy!(obj::CBSOCModel)

cb_destroy!(obj::CBSumModel)

cb_destroy!(obj::CBPSCVariableMetricSelection)

cb_destroy!(obj::CBVariableMetricSVDSelection)

cb_destroy!(obj::CBQPDirectKKTSolver)

cb_destroy!(obj::CBQPIterativeKKTHAeqSolver)

cb_destroy!(obj::CBQPIterativeKKTHASolver)

cb_destroy!(obj::CBQPKKTSolverComparison)

cb_destroy!(obj::CBSumBundleHandler)

cb_destroy!(obj::CBQPConeModelBlock)

cb_destroy!(obj::CBQPSumModelBlock)

cb_destroy!(obj::CBUQPConeModelBlock)

cb_destroy!(obj::CBUQPSumModelBlock)

cb_destroy!(obj::CBMinRes)

cb_destroy!(obj::CBPCG)

cb_destroy!(obj::CBPsqmr)

cb_destroy!(obj::CBQPKKTSubspaceHPrecond)

cb_destroy!(obj::CBSumBundle)

cb_destroy!(obj::CBBundleSolver)

cb_destroy!(obj::CBBundleTerminator)

cb_destroy!(obj::CBClock)

cb_destroy!(obj::CBMicroseconds)

cb_diag(A::CBMatrix)

returns a column vector v consisting of the elements v(i)=(*this)(i,i), 0<=i<min(row dimension,column dimension)

cb_diag(A::CBIndexmatrix)

returns a column vector v consisting of the elements v(i)=A(i,i), 0<=i<min(row dimension,column dimension)

cb_diag(A::CBSymmatrix)

returns a column vector v consisting of the elements v(i)=(*this)(i,i), 0<=i<row dimension

cb_diag(A::CBSparsesym)

returns the diagonal of A as a dense Matrix vector

cb_diagonal_bounds_scaling_update!(self::CBBundleDenseTrustRegionProx, param0::CBMatrix)

• @brief if supported, Dupdate has to contain nonnegative numbers that are permanently added to the diagonal here. It is important to keep track of this change only if afterwards updateQPcosts is called before computeQPcosts. In this case the only nonzero enries in Dupdate must be those of delta_index

cb_diagonal_bounds_scaling_update!(self::CBBundleDiagonalTrustRegionProx, D_update::CBMatrix)

• @brief if supported, Dupdate has to contain nonnegative numbers that are permanently added to the diagonal here. It is important to keep track of this change only if afterwards updateQPcosts is called before computeQPcosts. In this case the only nonzero enries in Dupdate must be those of delta_index

cb_diagonal_bounds_scaling_update!(self::CBBundleDLRTrustRegionProx, param0::CBMatrix)

• @brief if supported, Dupdate has to contain nonnegative numbers that are permanently added to the diagonal here. It is important to keep track of this change only if afterwards updateQPcosts is called before computeQPcosts. In this case the only nonzero enries in Dupdate must be those of delta_index

cb_diagonal_scaling_heuristic_update!(self::CBBundleLowRankTrustRegionProx, param0::CBMatrix)

• @brief if supported, Dupdate has to contain nonnegative numbers that are permanently added to the diagonal here. It is important to keep track of this change only if afterwards updateQPcosts is called before computeQPcosts. In this case the only nonzero enries in Dupdate must be those of delta_index

cb_dim(self::CBMatrix)

returns the dimension rows * columns when the matrix is regarded as a vector

cb_dim(self::CBIndexmatrix)

returns the dimension rows * columns when the matrix is regarded as a vector

cb_dim(self::CBSparsemat)

returns the dimension rows * columns when the matrix is regarded as a vector

cb_dim(self::CBSymmatrix)

returns the dimension rows * columns when the matrix is regarded as a vector

cb_dim(self::CBSparsesym)

returns the dimension rows * columns when the matrix is regarded as a vector

cb_dim(self::CBCMgramdense)

returns the order of the represented symmetric matrix

cb_dim(self::CBCMgramsparse)

returns the order of the represented symmetric matrix

cb_dim(self::CBCMgramsparse_withoutdiag)

returns the order of the represented symmetric matrix

cb_dim(self::CBCMlowrankdd)

returns the order of the represented symmetric matrix

cb_dim(self::CBCMlowranksd)

returns the order of the represented symmetric matrix

cb_dim(self::CBCMlowrankss)

returns the order of the represented symmetric matrix

cb_dim(self::CBCMsingleton)

returns the order of the represented symmetric matrix

cb_dim(self::CBCMsymdense)

returns the order of the represented symmetric matrix

cb_dim(self::CBCMsymsparse)

returns the order of the represented symmetric matrix

cb_dim(self::CBBundleDenseTrustRegionProx)

returns the order of the matrix

cb_dim(self::CBBundleDiagonalTrustRegionProx)

returns the dimension of the diagonal

cb_dim2(self::CBMatrix)

returns the number of rows in _nr and the number of columns in _nc

cb_dim2(self::CBIndexmatrix)

returns the number of rows in _nr and the number of columns in _nc

cb_dim2(self::CBSparsemat)

returns the number of rows in _nr and the number of columns in _nc

cb_dim2(self::CBSymmatrix)

returns the number of rows in _nr and _nc

cb_dim2(self::CBSparsesym)

returns the number of rows in _nr and the number of columns in _nc

cb_dim_constraints!(self::CBQPConeModelBlock)

returns the dimension of the system describing the model set (may contain further constraints)

cb_dim_constraints!(self::CBQPSumModelBlock)

returns the dimension of the system describing the model set (may contain further constraints)

cb_dim_model!(self::CBQPConeModelBlock)

returns the dimension of the model set (here the same as the bundle size)

cb_dim_model!(self::CBQPSumModelBlock)

returns the dimension of the model set (here the same as the bundle size)

cb_display(self::CBMatrix, precision::Integer = 0, width::Integer = 0, screenwidth::Integer = 0)

• @brief displays a matrix in a pretty way for bounded screen widths; for variables of value zero default values are used.

cb_display(self::CBIndexmatrix, precision::Integer = 0, width::Integer = 0, screenwidth::Integer = 0)

• @brief displays a matrix in a pretty way for bounded screen widths; for variables of value zero default values are used.

cb_display(self::CBSparsemat, precision::Integer = 0, width::Integer = 0, screenwidth::Integer = 0)

• @brief displays a matrix in a pretty way for bounded screen widths; for variables of value zero default values are used.

cb_display(self::CBSymmatrix, precision::Integer = 0, width::Integer = 0, screenwidth::Integer = 0)

• @brief displays a matrix in a pretty way for bounded screen widths; for variables of value zero default values are used.

cb_display(self::CBSparsesym, precision::Integer = 0, width::Integer = 0, screenwidth::Integer = 0)

• @brief displays a matrix in a pretty way for bounded screen widths; for variables of value zero default values are used.

cb_display(self::CBCMgramdense)

display constraint information

cb_display(self::CBCMgramsparse)

display constraint information

cb_display(self::CBCMgramsparse_withoutdiag)

display constraint information

cb_display(self::CBCMlowrankdd)

display constraint information

cb_display(self::CBCMlowranksd)

display constraint information

cb_display(self::CBCMlowrankss)

display constraint information

cb_display(self::CBCMsingleton)

display constraint information

cb_display(self::CBCMsymdense)

display constraint information

cb_display(self::CBCMsymsparse)

display constraint information

cb_display(self::CBMinorantPointer, precision::Integer = 8)

output the Minorant in a nice format

cb_display_model_values!(self::CBQPSumModelBlock, y::CBMatrix, global_bundle::CBMinorantBundle, startindex_bundle::Integer)

output for debbuging purposes

cb_dnorm_sqr(self::CBBundleDenseTrustRegionProx, B::CBMinorantPointer)

returns $\|B\|^2_{H^{-1}}$ (with weightu included in H)

cb_dnorm_sqr(self::CBBundleDiagonalTrustRegionProx, B::CBMinorantPointer)

returns \f$\|B\|^2_{H^{-1}}\f$

cb_dnorm_sqr(self::CBBundleDLRTrustRegionProx, B::CBMinorantPointer)

returns $\|B\|^2_{H^{-1}}$ (with weight included)

cb_dnorm_sqr(self::CBBundleIdProx, B::CBMinorantPointer)

returns \f$\|B\|^2_{H^{-1}}\f$

cb_dnorm_sqr(self::CBBundleLowRankTrustRegionProx, B::CBMinorantPointer)

returns $\|B\|^2_{H^{-1}}$ (with weight included)

cb_do_step!(self::CBAFTData, point_id::Integer)

if the candidate information is available and consitent for point_id, copy it from cand to center and return 0, otherwise return 1

cb_do_step!(self::CBBoxData, point_id::Integer)

if the candidate information is available and consitent for point_id, copy it from cand to center and return 0, otherwise return 1

cb_do_step!(self::CBNNCData, point_id::Integer)

if the candidate information is available and consitent for point_id, copy it from cand to center and return 0, otherwise return 1

cb_do_step!(self::CBPSCData, point_id::Integer)

if the candidate information is available and consitent for point_id, copy it from cand to center and return 0, otherwise return 1

cb_do_step!(self::CBSOCData, point_id::Integer)

if the candidate information is available and consitent for point_id, copy it from cand to center and return 0, otherwise return 1

cb_do_step!(self::CBQPConeModelBlock, alpha::Real, y::CBMatrix, global_bundle::CBMinorantBundle, startindex_bundle::Integer)

move in the last computed step direction by a step of length alpha and compute and store the violation in this point for later use in

cb_do_step!(self::CBQPSumModelBlock, alpha::Real, y::CBMatrix, global_bundle::CBMinorantBundle, startindex_bundle::Integer)

move in the last computed step direction by a step of length alpha and compute and store the violation in this point for later use in

cb_dual_norm_squared(self::CBMinorantPointer, D::Union{<:CBMatrix,Nothing} = nothing)

Compute the dual norm squared of this for the given diagonal matrix D (identity if not given), i.e. \f$\|(*this)\|^2_{D^{-1}}\f$

cb_dualviol_2normsqr!(self::CBQPConeModelBlock)

return the squared Euclidean norm of the model violation

cb_dualviol_2normsqr!(self::CBQPSumModelBlock)

return the squared Euclidean norm of the dual model violation

cb_eig(self::CBSymmatrix, P::CBMatrix, d::CBMatrix, sort_non_decreasingly::Bool = true)

computes an eigenvalue decomposition PDiag(d)tranpose(P)=(*this) by symmetric QR; returns 0 on success,

cb_elapsed_time(self::CBClock)

call time() and print the result in format "hh:mm:ss", togehter with current date and time, to out

cb_empty(self::CBMinorantPointer)

returns true if the pointer is empty

cb_enlarge_below!(self::CBMatrix, addnr::Integer)

enlarge the matrix by addnr>=0 rows without intializaton of the new rows, returns *this (marked as not initialized if addnr>0)

cb_enlarge_below!(self::CBMatrix, addnr::Integer, d::Real)

enlarge the matrix by addnr>=0 rows intializing the new rows by value d, returns *this

cb_enlarge_below!(self::CBMatrix, addnr::Integer, dp::Union{<:AbstractVector{Cdouble},Nothing}, d::Real = 1.)

enlarge the matrix by addnr>=0 rows intializing the new rows by the values pointed to by dp times d, returns *this

cb_enlarge_below!(self::CBIndexmatrix, addnr::Integer)

enlarge the matrix by addnr>=0 rows without intializaton of the new rows, returns *this (marked as not initialized if nc>0)

cb_enlarge_below!(self::CBIndexmatrix, addnr::Integer, d::Integer)

enlarge the matrix by addnr>=0 rows intializing the new rows by value d, returns *this

cb_enlarge_below!(self::CBIndexmatrix, addnr::Integer, dp::Union{<:AbstractVector{Cint},Nothing}, d::Integer = 1)

enlarge the matrix by addnr>=0 rows intializing the new rows by the values pointed to by dp times d, returns *this

cb_enlarge_below!(self::CBSymmatrix, addn::Integer)

increases the order of the matrix by appending storage for further addn rows and columns (marked as not initiliazed if addn>0, no changes if addn<=0)

cb_enlarge_below!(self::CBSymmatrix, addn::Integer, d::Real)

increases the order of the matrix by appending storage for further addn rows and columns initialized to d (no changes if addn<=0);

cb_enlarge_right!(self::CBMatrix, addnc::Integer)

enlarge the matrix by addnc>=0 columns without intializaton of the new columns, returns *this (marked as not initialized if nr>0)

cb_enlarge_right!(self::CBMatrix, addnc::Integer, d::Real)

enlarge the matrix by addnc>=0 columns intializing the new columns by value d, returns *this

cb_enlarge_right!(self::CBMatrix, addnc::Integer, dp::Union{<:AbstractVector{Cdouble},Nothing}, d::Real = 1.)

enlarge the matrix by addnc>=0 columns intializing the new columns by the values pointed to by dp times d, returns *this

cb_enlarge_right!(self::CBIndexmatrix, addnc::Integer)

enlarge the matrix by addnc>=0 columns without intializaton of the new columns, returns *this (marked as not initialized if nr>0)

cb_enlarge_right!(self::CBIndexmatrix, addnc::Integer, d::Integer)

enlarge the matrix by addnc>=0 columns intializing the new columns by value d, returns *this

cb_enlarge_right!(self::CBIndexmatrix, addnc::Integer, dp::Union{<:AbstractVector{Cint},Nothing}, d::Integer = 1)

enlarge the matrix by addnc>=0 columns intializing the new columns by the values pointed to by dp times d, returns *this

cb_ensure_feasibility!(self::CBLPGroundset, y::CBMatrix, ychanged::Bool, Hp::Union{<:CBBundleProxObject,Nothing}, relprec::Real = 1e-10)

makes y feasible if not so, see Groundset::ensure_feasibility()

cb_ensure_feasibility!(self::CBUnconstrainedGroundset, y::CBMatrix, ychanged::Bool, Hp::Union{<:CBBundleProxObject,Nothing} = nothing, relprec::Real = 1e-10)

• @brief if the groundset_id changed, it checks feasibility of y with respect to the given precision. If infeasible it replaces y by its projection with respect to the norm of Hp and sets ychanged to true.

  The routine is called by the internal bundle solver to check whether the given center is still valid (in some applications the groundset might change during the runtime of the bundle method), where, if @a ychanged is false on input, validity of @a y was already checked at a point in time when the groundset had the @a ingroundsetid. If @a ychanged==false and the groundsetid is still the same, then @a y is simply assumed to be still correct (the precision is not even looked at in this case). Otherwise the routine checks the validitiy of @a y with respect to the given precision. If feasible, it returns the new groundsetid in @a ingroundsetid and keeps @a ychanged unaltered. If @a y is infeasible, the rountine computes its projection onto the feasible set with respect to the norm of @a Hp (if ==0 then the Euclidean norm is used), stores it in @a y, sets @a ychanged to true, sets @a ingroundsetid to the current groundset_id and returns

  1. Should anything go wrong, it returns 1.

  This concrete base class represents the unconstrained case, so feasiblity only checks the dimension and never requires projections.

cb_equal(A::CBMatrix, B::CBMatrix)

returns true if both matrices have the same size and the same elements

cb_equal(A::CBIndexmatrix, b::CBIndexmatrix)

returns true if both matrices have the same size and the same elements

cb_equal(A::CBSparsemat, B::CBSparsemat, eqtol::Real)

returns 1 if both matrices are identical, 0 otherwise

cb_equal(A::CBSparsesym, B::CBSparsesym, eqtol::Real)

returns 1 if both matrices are identical, 0 otherwise

cb_equal(self::CBCMgramdense, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equal(self::CBCMgramsparse, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equal(self::CBCMgramsparse_withoutdiag, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equal(self::CBCMlowrankdd, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equal(self::CBCMlowranksd, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equal(self::CBCMlowrankss, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equal(self::CBCMsingleton, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equal(self::CBCMsymdense, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equal(self::CBCMsymsparse, p::Union{<:CBCoeffmat,Nothing}, tol::Real = 1e-6)

returns 1, if p is the same derived class and entries differ by less than tol, otherwise zero

cb_equals(self::CBMinorantPointer, mp::CBMinorantPointer, tol::Real = 1e-10)

they are equal if they point to the same object or are both 0. If not, they differ if their matrix representations differ; if not, they differ if the entries differ by at least tol*(1.+fabs(this->offset())

cb_eval_function!(self::CBAFTModel, y_id::Integer, y::CBMatrix, nullstep_bound::Real, relprec::Real)

see BundleModel::eval_function

cb_eval_function!(self::CBSumModel, y_id::Integer, y::CBMatrix, nullstep_bound::Real, relprec::Real)

see BundleModel::eval_function

cb_eval_model(self::CBSumBundleHandler, yid::Integer, y::CBMatrix)

evaluate the model value

cb_eval_model!(self::CBAFTModel, y_id::Integer, y::CBMatrix, relprec::Real)

see BundleModel::eval_model

cb_eval_model!(self::CBSumModel, y_id::Integer, y::CBMatrix, relprec::Real)

see BundleModel::eval_model

cb_evaluate(self::CBMinorantPointer, yid::Integer, y::CBMatrix, with_constant::Bool = true)

negative ids are allowed and indicate there is no need to memorize this result, returns CBminusinfinity if empty, otherwise offset+ip(minorant,y)

cb_evaluate(self::CBMinorantUseData, yid::Integer, y::CBMatrix, with_constant::Bool = true)

evaluate the minorant for @a y unluess @a yid allows to retrieve a previous evaluation

cb_evaluate_projection!(self::CBPSCAffineFunction, current_point::CBMatrix, P::CBMatrix, relprec::Real, projected_Ritz_vectors::CBMatrix, projected_Ritz_values::CBMatrix)

see PSCOracle::evaluate_projection()

cb_evaluate_projection!(self::CBSOCSupportFunction, current_point::CBMatrix, P::CBMatrix, relprec::Real)

see SOCOracle::evaluate()

cb_evaluate_trace(self::CBQPConeModelBlock)

evaluate the left hand side of the trace constraint for modelx

cb_evaluate_trace(self::CBUQPConeModelBlock)

evaluate the left hand side of the trace constraint for modelx

cb_extend!(self::CBBoxPrimalExtender, param0::CBPrimalData)

like in PrimalExtender, called by ConicBundle to update internal PrimalData objects, has to return 0 on success

cb_extend!(self::CBPSCPrimalExtender, param0::CBPrimalData)

like in PrimalExtender, called by ConicBundle to update internal PrimalData objects, has to return 0 on success

cb_extend!(self::CBSOCPrimalExtender, param0::CBPrimalData)

like in PrimalExtender, called by ConicBundle to update internal PrimalData objects, has to return 0 on success

cb_extend!(self::CBCFunctionMinorantExtender, minorant::CBMinorant, n_coords::Integer, indices::Union{<:AbstractVector{Integer},Nothing})

see MinorantExtender::extend() for explanations

cb_extend!(self::CBNNCBoxSupportMinorantExtender, minorant::CBMinorant, n_coords::Integer, indices::Union{<:AbstractVector{Integer},Nothing})

@brief called by ConicBundle to update internal Minorant objects, has to return 0 on success

    for each relevant index i the minorant value is set to the projection

of 0 onto the interval [lowerbound(i),upperbound(i)]

    @param[in,out] minorant  (Minorant&)
        it holds a (possibly aggregated) minorant that was generated
        from minorants returned by oracle calls, e.g. as in
  FunctionOracle::evaluate()

    @param[in] n_coords (int)
        the number of coordinate positions that have to be filled in

    @param[out] new_subgradient_values  (DVector &)
  the indices of these coordinate positions (sorted in
  strictly increasing order)

@return - 0 on success, - 1 if extension/update is impossible

cb_extend!(self::CBPSCAffineMinorantExtender, minorant::CBMinorant, n_coords::Integer, indices::Union{<:AbstractVector{Integer},Nothing})

@brief called by ConicBundle to update internal Minorant objects, has to return 0 on success

    @param[in,out] minorant  (Minorant&)
        it holds a (possibly aggregated) minorant that was generated
        from minorants returned by oracle calls, e.g. as in
  FunctionOracle::evaluate() If PrimalData was provided in these
  minorants, this will be aggregated along and will also be
  available in this minorant.

    @param[in] n_coords (int)
        the number of coordinate positions that have to be filled in

    @param[out] new_subgradient_values  (DVector &)
  the indices of these coordinate positions (sorted in
  strictly increasing order)

@return - 0 on success, - 1 if extension/update is impossible

cb_extend!(self::CBSOCSupportMinorantExtender, minorant::CBMinorant, n_coords::Integer, indices::Union{<:AbstractVector{Integer},Nothing})

@brief called by ConicBundle to update internal Minorant objects, has to return 0 on success

    for each relevant index i the minorant value is set to the projection

of 0 onto the interval [lowerbound(i),upperbound(i)]

    @param[in,out] minorant  (Minorant&)
        it holds a (possibly aggregated) minorant that was generated
        from minorants returned by oracle calls, e.g. as in
  FunctionOracle::evaluate()

    @param[in] n_coords (int)
        the number of coordinate positions that have to be filled in

    @param[out] new_subgradient_values  (DVector &)
  the indices of these coordinate positions (sorted in
  strictly increasing order)

@return - 0 on success, - 1 if extension/update is impossible

cb_extend_Box!(self::CBBoxPrimalExtender, param0::CBMatrix)

called by ConicBundle to update internal Ritz_vectors, has to return 0 on success

cb_extend_Ritz!(self::CBPSCPrimalExtender, param0::CBMatrix)

called by ConicBundle to update internal Ritz_vectors, has to return 0 on success

cb_extend_SOC!(self::CBSOCPrimalExtender, param0::CBMatrix)

called by ConicBundle to update internal SOC vectors, has to return 0 on success

cb_extract_SOCvector!(self::CBSOCSupportFunction, SOCvec::CBMatrix, SOCminorant::Union{<:CBMinorant,Nothing})

see SOCOracle::extract_SOCvector()

cb_find(self::CBMatrix, tol::Real = 1e-10)

returns an Indexmatrix ind so that (*this)(ind(i)) 0<=i<ind.dim() runs through all nonzero elements

cb_find(self::CBIndexmatrix)

returns an Indexmatrix ind so that (*this)(ind(i)) 0<=i<ind.dim() runs through all nonzero elements

cb_find_number(self::CBMatrix, num::Real = 0., tol::Real = 1e-10)

returns an Indexmatrix ind so that (*this)(ind(i)) 0<=i<ind.dim() runs through all elements of value num

cb_find_number(self::CBIndexmatrix, num::Integer = 0)

returns an Indexmatrix ind so that (*this)(ind(i)) 0<=i<ind.dim() runs through all elements having value num

cb_floor(A::CBMatrix)

returns a matrix with elements (i,j)=floor((*this)(i,j)) for all i,j

cb_floor!(self::CBMatrix)

sets (this)(i,j)=floor((this)(i,j)) for all i,j and returns *this

cb_form_bundlevecs!(self::CBSOCData, max_columns::Integer)

starting with aggregate and cand_SOCvec add further ones as needed

cb_from_dim(self::CBAffineFunctionTransformation)

returns the dimension of the input argument or -1 if it is unknown

cb_generate_minorant!(self::CBPSCAffineFunction, P::CBMatrix)

see PSCOracle::generate_minorant()

cb_generate_minorant!(self::CBSOCSupportFunction, SOCvec::CBMatrix)

see SOCOracle::generate_minorant()