Optimizer()

Create a new Optimizer object.

Set optimizer attributes using MOI.RawOptimizerAttribute or JuMP.set_optimizer_atttribute.

For a list of supported parameter names, see Clp.SUPPORTED_PARAMETERS.

Example

using JuMP, Clp
model = JuMP.Model(Clp.Optimizer)
set_optimizer_attribute(model, "LogLevel", 0)

typedef for cbc cut callback osiSolver needs to be an OsiSolverInterface object, osiCuts is an OsiCuts object and appdata is a pointer that will be passed to the cut generation, you can use it to point to a data structure with information about the original problem, for instance

typedef for user call back. The cvec are constructed so don't need to be const

ClpSolve_delete(solve)

Destructor

ClpSolve_new()

Default constructor

ClpSolve_setPresolveType(arg1, amount, extraInfo)

amount: (see ClpSolve::PresolveType) 0 - presolve on 1 - presolve off 2 - presolve number 3 - presolve number cost – pass extraInfo == -1 for default behavior

ClpSolve_setSolveType(arg1, method, extraInfo)

method: (see ClpSolve::SolveType) 0 - dual simplex 1 - primal simplex 2 - primal or sprint 3 - barrier 4 - barrier no crossover 5 - automatic 6 - not implemented – pass extraInfo == -1 for default behavior

Clp_Version()

Clp library version number as string.

Clp_VersionMajor()

Major number of Clp library version.

Clp_VersionMinor()

Minor number of Clp library version.

Clp_VersionRelease()

Release number of Clp library version.

Clp_addColumns(model, number, columnLower, columnUpper, objective, columnStarts, rows, elements)

Add columns

Clp_addRows(model, number, rowLower, rowUpper, rowStarts, columns, elements)

Add rows

Clp_algorithm(model)

Current (or last) algorithm

Clp_checkSolution(model)

Just check solution (for external use) - sets sum of infeasibilities etc

Clp_chgColumnLower(model, columnLower)

Change column lower bounds

Clp_chgColumnUpper(model, columnUpper)

Change column upper bounds

Clp_chgObjCoefficients(model, objIn)

Change objective coefficients

Clp_chgRowLower(model, rowLower)

Change row lower bounds

Clp_chgRowUpper(model, rowUpper)

Change row upper bounds

Clp_clearCallBack(model)

Unset Callback function

Clp_columnLower(model)

Column Lower

Clp_columnName(model, iColumn, name)

Fill in array (at least lengthNames+1 long) with a column name

Clp_columnUpper(model)

Column Upper

Clp_copyInIntegerInformation(model, information)

Copy in integer informations

Clp_copyNames(model, rowNames, columnNames)

Copies in names

Clp_copyinStatus(model, statusArray)

Copy in status vector

Clp_crash(model, gap, pivot)

Crash - at present just aimed at dual, returns -2 if dual preferred and crash basis created -1 if dual preferred and all slack basis preferred 0 if basis going in was not all slack 1 if primal preferred and all slack basis preferred 2 if primal preferred and crash basis created.

if gap between bounds <="gap" variables can be flipped

If "pivot" is 0 No pivoting (so will just be choice of algorithm) 1 Simple pivoting e.g. gub 2 Mini iterations

Clp_deleteColumns(model, number, which)

Deletes columns

Clp_deleteIntegerInformation(model)

Drop integer informations

Clp_deleteModel(model)

Destructor

Clp_deleteRows(model, number, which)

Deletes rows

Clp_dropNames(model)

Drops names - makes lengthnames 0 and names empty

Clp_dual(model, ifValuesPass)

Dual algorithm - see ClpSimplexDual.hpp for method

Clp_dualBound(model)

Dual bound

Clp_dualColumnSolution(model)

Reduced costs

Clp_dualFeasible(model)

If problem is dual feasible

Clp_dualObjectiveLimit(model)

Dual objective limit

Clp_dualRowSolution(model)

Dual row solution

Clp_dualTolerance(model)

Dual tolerance to use

Clp_freeRay(model, ray)

Frees a infeasibility or unbounded ray.

Clp_getColLower(model)

Column Lower

Clp_getColSolution(model)

Primal column solution

Clp_getColUpper(model)

Column Upper

Clp_getIterationCount(model)

Number of iterations

Clp_getNumCols(model)

Number of columns

Clp_getNumElements(model)

Number of elements in matrix

Clp_getNumRows(model)

Number of rows

Clp_getObjCoefficients(model)

Objective

Clp_getObjSense(model)

Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore

Clp_getObjValue(model)

Objective value

Clp_getReducedCost(model)

Reduced costs

Clp_getRowActivity(model)

Primal row solution

Clp_getRowLower(model)

Row lower

Clp_getRowPrice(model)

Dual row solution

Clp_getRowUpper(model)

Row upper

Clp_hitMaximumIterations(model)

Returns true if hit maximum iterations (or time)

Clp_idiot(model, tryhard)

Solve the problem with the idiot code

Clp_infeasibilityCost(model)

Infeasibility cost

Clp_infeasibilityRay(model)

Gives Infeasibility ray.

Use Clp_freeRay to free the returned array.

Returns

infeasibility ray, or NULL returned if none/wrong.

Clp_initialBarrierNoCrossSolve(model)

Barrier initial solve, no crossover

Clp_initialBarrierSolve(model)

Barrier initial solve

Clp_initialDualSolve(model)

Dual initial solve

Clp_initialPrimalSolve(model)

Primal initial solve

Clp_initialSolve(model)

General solve algorithm which can do presolve. See ClpSolve.hpp for options

Clp_initialSolveWithOptions(model, arg2)

Pass solve options. (Exception to direct analogue rule)

Clp_integerInformation(model)

Integer information

Clp_isAbandoned(model)

Are there a numerical difficulties?

Clp_isDualObjectiveLimitReached(model)

Is the given dual objective limit reached?

Clp_isIterationLimitReached(model)

Iteration limit reached?

Clp_isPrimalObjectiveLimitReached(model)

Is the given primal objective limit reached?

Clp_isProvenDualInfeasible(model)

Is dual infeasiblity proven?

Clp_isProvenOptimal(model)

Is optimality proven?

Clp_isProvenPrimalInfeasible(model)

Is primal infeasiblity proven?

Clp_lengthNames(model)

length of names (0 means no names0

Clp_loadProblem(model, numcols, numrows, start, index, value, collb, colub, obj, rowlb, rowub)

Loads a problem (the constraints on the rows are given by lower and upper bounds). If a pointer is NULL then the following values are the default: <ul> <li> <code>colub</code>: all columns have upper bound infinity <li> <code>collb</code>: all columns have lower bound 0 <li> <code>rowub</code>: all rows have upper bound infinity <li> <code>rowlb</code>: all rows have lower bound -infinity <li> <code>obj</code>: all variables have 0 objective coefficient </ul>

Just like the other loadProblem() method except that the matrix is given in a standard column major ordered format (without gaps).

Clp_maximumSeconds(model)

Maximum time in seconds (from when set called)

Clp_newModel()

Default constructor

Clp_numberColumns(model)

Number of columns

Clp_numberDualInfeasibilities(model)

Number of dual infeasibilities

Clp_numberIterations(model)

Number of iterations

Clp_numberPrimalInfeasibilities(model)

Number of primal infeasibilities

Clp_numberRows(model)

Number of rows

Clp_objective(model)

Objective

Clp_objectiveOffset(model)

Objective offset

Clp_objectiveValue(model)

Objective value

Clp_optimizationDirection(model)

Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore

Clp_perturbation(model)

Perturbation: 50 - switch on perturbation 100 - auto perturb if takes too long (1.0e-6 largest nonzero) 101 - we are perturbed 102 - don't try perturbing again default is 100 others are for playing

Clp_primal(model, ifValuesPass)

Primal algorithm - see ClpSimplexPrimal.hpp for method

Clp_primalColumnSolution(model)

Primal column solution

Clp_primalFeasible(model)

If problem is primal feasible

Clp_primalRowSolution(model)

Primal row solution

Clp_primalTolerance(model)

Primal tolerance to use

Clp_printModel(model, prefix)

Print model for debugging purposes

Clp_problemName(model, maxNumberCharacters, array)

Fills in array with problem name

Clp_readMps(model, filename, keepNames, ignoreErrors)

Read an mps file from the given filename

Clp_registerCallBack(model, userCallBack)

Pass in Callback function. Message numbers up to 1000000 are Clp, Coin ones have 1000000 added

Clp_resize(model, newNumberRows, newNumberColumns)

Resizes rim part of model

Clp_restoreModel(model, fileName)

Restore model from file, returns 0 if success, deletes current model

Clp_rowLower(model)

Row lower

Clp_rowName(model, iRow, name)

Fill in array (at least lengthNames+1 long) with a row name

Clp_rowUpper(model)

Row upper

Clp_saveModel(model, fileName)

Save model to file, returns 0 if success. This is designed for use outside algorithms so does not save iterating arrays etc. It does not save any messaging information. Does not save scaling values. It does not know about all types of virtual functions.

Clp_scaling(model, mode)

Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later)

Clp_scalingFlag(model)

Gets scalingFlag

Clp_secondaryStatus(model)

Secondary status of problem - may get extended 0 - none 1 - primal infeasible because dual limit reached 2 - scaled problem optimal - unscaled has primal infeasibilities 3 - scaled problem optimal - unscaled has dual infeasibilities 4 - scaled problem optimal - unscaled has both dual and primal infeasibilities

Clp_setAlgorithm(model, value)

Set algorithm

Clp_setColumnName(model, iColumn, name)

Set column name - Nice if they are short - 8 chars or less I think

Clp_setLogLevel(model, value)

Amount of print out: 0 - none 1 - just final 2 - just factorizations 3 - as 2 plus a bit more 4 - verbose above that 8,16,32 etc just for selective debug

Clp_setObjSense(model, objsen)

Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore

Clp_setProblemStatus(model, problemStatus)

Set problem status

Clp_setRowName(model, iRow, name)

Set row name - Nice if they are short - 8 chars or less I think

Clp_setUserPointer(model, pointer)

User pointer for whatever reason

Clp_status(model)

Status of problem: 0 - optimal 1 - primal infeasible 2 - dual infeasible 3 - stopped on iterations etc 4 - stopped due to errors

Clp_statusArray(model)

Return address of status array (char[numberRows+numberColumns])

Clp_statusExists(model)

See if status array exists (partly for OsiClp)

Clp_sumDualInfeasibilities(model)

Sum of dual infeasibilities

Clp_sumPrimalInfeasibilities(model)

Sum of primal infeasibilities

Clp_unboundedRay(model)

Gives ray in which the problem is unbounded.

Use Clp_freeRay to free the returned array.

Returns

unbounded ray, or NULL returned if none/wrong.

Clp_writeMps(model, filename, formatType, numberAcross, objSense)

Write an mps file to the given filename

Format type is 0 = normal, 1 = extra or 2 = hex. Number across is 1 or 2. Use objSense = -1D to flip the objective function around.

_farkas_variable_dual(model::Optimizer, col::Cint)

Return a Farkas dual associated with the variable bounds of col.

Compute the Farkas dual as:

ā * x = λ' * A * x <= λ' * b = -β + sum(āᵢ * Uᵢ | āᵢ < 0) + sum(āᵢ * Lᵢ | āᵢ > 0)

The Farkas dual of the variable is ā, and it applies to the upper bound if ā < 0, and it applies to the lower bound if ā > 0.

_index_map(src::OptimizerCache)

Create an IndexMap mapping the variables and constraints in OptimizerCache to their corresponding 1-based columns and rows.

maximumIterations(model)

Maximum number of iterations