Cgl 0.60.2

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Clp_C_Interface.h
Go to the documentation of this file.
1 /* $Id: Clp_C_Interface.h 2449 2019-04-08 03:34:28Z stefan $ */
2 /*
3 Copyright (C) 2002, 2003 International Business Machines Corporation
4 and others. All Rights Reserved.
5
6 This code is licensed under the terms of the Eclipse Public License (EPL).
7 */
8 #ifndef ClpSimplexC_H
9 #define ClpSimplexC_H
10
11 /* include all defines and ugly stuff */
12 #include "Coin_C_defines.h"
13
14 #if defined(CLP_EXTERN_C)
15 typedef struct {
16 ClpSolve options;
17 } Clp_Solve;
18 #else
19 typedef void Clp_Solve;
20 #endif
21
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
40 COINLIBAPI const char *COINLINKAGE Clp_Version(void);
42 COINLIBAPI int COINLINKAGE Clp_VersionMajor(void);
44 COINLIBAPI int COINLINKAGE Clp_VersionMinor(void);
46 COINLIBAPI int COINLINKAGE Clp_VersionRelease(void);
62
64 COINLIBAPI Clp_Simplex *COINLINKAGE Clp_newModel(void);
66 COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex *model);
68 COINLIBAPI Clp_Solve *COINLINKAGE ClpSolve_new();
70 COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve *solve);
88 COINLIBAPI void COINLINKAGE Clp_loadProblem(Clp_Simplex *model, const int numcols, const int numrows,
89 const CoinBigIndex *start, const int *index,
90 const double *value,
91 const double *collb, const double *colub,
92 const double *obj,
93 const double *rowlb, const double *rowub);
94
95 /* read quadratic part of the objective (the matrix part) */
96 COINLIBAPI void COINLINKAGE
97 Clp_loadQuadraticObjective(Clp_Simplex *model,
98 const int numberColumns,
99 const CoinBigIndex *start,
100 const int *column,
101 const double *element);
103 COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex *model, const char *filename,
104 int keepNames,
105 int ignoreErrors);
110 COINLIBAPI int COINLINKAGE Clp_writeMps(Clp_Simplex *model, const char *filename,
111 int formatType,
112 int numberAcross,
113 double objSense);
115 COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex *model, const char *information);
117 COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex *model);
119 COINLIBAPI void COINLINKAGE Clp_resize(Clp_Simplex *model, int newNumberRows, int newNumberColumns);
121 COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex *model, int number, const int *which);
123 COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex *model, int number, const double *rowLower,
124 const double *rowUpper,
125 const CoinBigIndex *rowStarts, const int *columns,
126 const double *elements);
127
129 COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex *model, int number, const int *which);
131 COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex *model, int number, const double *columnLower,
132 const double *columnUpper,
133 const double *objective,
134 const CoinBigIndex *columnStarts, const int *rows,
135 const double *elements);
137 COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex *model, const double *rowLower);
139 COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex *model, const double *rowUpper);
141 COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex *model, const double *columnLower);
143 COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex *model, const double *columnUpper);
145 COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex *model, const double *objIn);
147 COINLIBAPI void COINLINKAGE Clp_modifyCoefficient(Clp_Simplex *model, int row, int column, double newElement,
148 bool keepZero);
150 COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex *model);
152 COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex *model, const char *const *rowNames,
153 const char *const *columnNames);
154
159 COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex *model);
161 COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex *model);
163 COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex *model);
164 COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex *model, double value);
166 COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex *model);
167 COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex *model, double value);
169 COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex *model);
170 COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex *model, double value);
172 COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex *model);
173 COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex *model, double value);
175 COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex *model, int maxNumberCharacters, char *array);
176 /* Sets problem name. Must have \0 at end. */
177 COINLIBAPI int COINLINKAGE
178 Clp_setProblemName(Clp_Simplex *model, int maxNumberCharacters, char *array);
180 COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex *model);
181 COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex *model, int numberIterations);
183 COINLIBAPI int maximumIterations(Clp_Simplex *model);
184 COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex *model, int value);
186 COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex *model);
187 COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex *model, double value);
189 COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex *model);
197 COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex *model);
199 COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex *model, int problemStatus);
207 COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex *model);
208 COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex *model, int status);
210 COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex *model);
211 COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex *model, double value);
213 COINLIBAPI double *COINLINKAGE Clp_primalRowSolution(Clp_Simplex *model);
215 COINLIBAPI double *COINLINKAGE Clp_primalColumnSolution(Clp_Simplex *model);
217 COINLIBAPI double *COINLINKAGE Clp_dualRowSolution(Clp_Simplex *model);
219 COINLIBAPI double *COINLINKAGE Clp_dualColumnSolution(Clp_Simplex *model);
221 COINLIBAPI double *COINLINKAGE Clp_rowLower(Clp_Simplex *model);
223 COINLIBAPI double *COINLINKAGE Clp_rowUpper(Clp_Simplex *model);
225 COINLIBAPI double *COINLINKAGE Clp_objective(Clp_Simplex *model);
227 COINLIBAPI double *COINLINKAGE Clp_columnLower(Clp_Simplex *model);
229 COINLIBAPI double *COINLINKAGE Clp_columnUpper(Clp_Simplex *model);
231 COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex *model);
232 /* Column starts in matrix */
233 COINLIBAPI const CoinBigIndex *COINLINKAGE Clp_getVectorStarts(Clp_Simplex *model);
234 /* Row indices in matrix */
235 COINLIBAPI const int *COINLINKAGE Clp_getIndices(Clp_Simplex *model);
236 /* Column vector lengths in matrix */
237 COINLIBAPI const int *COINLINKAGE Clp_getVectorLengths(Clp_Simplex *model);
238 /* Element values in matrix */
239 COINLIBAPI const double *COINLINKAGE Clp_getElements(Clp_Simplex *model);
241 COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex *model);
243 COINLIBAPI char *COINLINKAGE Clp_integerInformation(Clp_Simplex *model);
250 COINLIBAPI double *COINLINKAGE Clp_infeasibilityRay(Clp_Simplex *model);
257 COINLIBAPI double *COINLINKAGE Clp_unboundedRay(Clp_Simplex *model);
259 COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex *model, double *ray);
261 COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex *model);
263 COINLIBAPI unsigned char *COINLINKAGE Clp_statusArray(Clp_Simplex *model);
265 COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex *model, const unsigned char *statusArray);
266 /* status values are as in ClpSimplex.hpp i.e. 0 - free, 1 basic, 2 at upper,
267 3 at lower, 4 superbasic, (5 fixed) */
268 /* Get variable basis info */
269 COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex *model, int sequence);
270 /* Get row basis info */
271 COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex *model, int sequence);
272 /* Set variable basis info (and value if at bound) */
273 COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex *model,
274 int sequence, int value);
275 /* Set row basis info (and value if at bound) */
276 COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex *model,
277 int sequence, int value);
278
280 COINLIBAPI void COINLINKAGE Clp_setUserPointer(Clp_Simplex *model, void *pointer);
281 COINLIBAPI void *COINLINKAGE Clp_getUserPointer(Clp_Simplex *model);
287 COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex *model,
288 clp_callback userCallBack);
290 COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex *model);
299 COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex *model, int value);
300 COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex *model);
302 COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex *model);
304 COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex *model, int iRow, char *name);
306 COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex *model, int iColumn, char *name);
308 COINLIBAPI void COINLINKAGE Clp_setRowName(Clp_Simplex *model, int iRow, char *name);
310 COINLIBAPI void COINLINKAGE Clp_setColumnName(Clp_Simplex *model, int iColumn, char *name);
311
319 COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex *model);
321 COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex *model, Clp_Solve *);
323 COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex *model);
325 COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex *model);
327 COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex *model);
329 COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex *model);
331 COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex *model, int ifValuesPass);
333 COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex *model, int ifValuesPass);
334 #ifndef SLIM_CLP
335
336 COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex *model, int tryhard);
337 #endif
338
339 COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex *model, int mode);
341 COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex *model);
356 COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex *model, double gap, int pivot);
362 COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex *model);
364 COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex *model);
366 COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex *model);
367 COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex *model, double value);
369 COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex *model);
370 COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex *model, double value);
379 COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex *model);
380 COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex *model, int value);
382 COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex *model);
384 COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex *model, int value);
386 COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex *model);
388 COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex *model);
390 COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex *model);
392 COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex *model);
399 COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex *model, const char *fileName);
402 COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex *model, const char *fileName);
403
406 COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex *model);
409 /******************** End of most useful part **************/
413 COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex *model);
415 COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex *model);
417 COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex *model);
419 COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex *model);
421 COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex *model);
423 COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex *model);
425 COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex *model);
427 COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex *model);
429 COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex *model);
431 COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex *model);
433 COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex *model);
435 COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex *model, double objsen);
437 COINLIBAPI const double *COINLINKAGE Clp_getRowActivity(Clp_Simplex *model);
439 COINLIBAPI const double *COINLINKAGE Clp_getColSolution(Clp_Simplex *model);
440 COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex *model, const double *input);
442 COINLIBAPI const double *COINLINKAGE Clp_getRowPrice(Clp_Simplex *model);
444 COINLIBAPI const double *COINLINKAGE Clp_getReducedCost(Clp_Simplex *model);
446 COINLIBAPI const double *COINLINKAGE Clp_getRowLower(Clp_Simplex *model);
448 COINLIBAPI const double *COINLINKAGE Clp_getRowUpper(Clp_Simplex *model);
450 COINLIBAPI const double *COINLINKAGE Clp_getObjCoefficients(Clp_Simplex *model);
452 COINLIBAPI const double *COINLINKAGE Clp_getColLower(Clp_Simplex *model);
454 COINLIBAPI const double *COINLINKAGE Clp_getColUpper(Clp_Simplex *model);
456 COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex *model);
458 COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex *model, const char *prefix);
459 /* Small element value - elements less than this set to zero,
460 default is 1.0e-20 */
461 COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex *model);
462 COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex *model, double value);
468 COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo);
469 COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which);
470
480 COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo);
481 COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *);
482
489 COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo);
490 COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *);
491
492 COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *);
493 COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which);
494 COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse);
495 COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *);
496
497 COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *);
498 COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual);
499
500 COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *);
501 COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton);
502
503 COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *);
504 COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton);
505
506 COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *);
507 COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton);
508
509 COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *);
510 COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten);
511
512 COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *);
513 COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing);
514
515 COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *);
516 COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree);
517
518 COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *);
519 COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol);
520
521 COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *);
522 COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow);
523
524 COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *);
525 COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton);
526
527 COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *);
528 COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action);
529
530 COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *);
531 COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value);
532
534 #ifdef __cplusplus
535 }
536 #endif
537 #endif
538
539 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
540 */
Clp_deleteColumns
COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex *model, int number, const int *which)
Deletes columns.
Clp_columnLower
COINLIBAPI double *COINLINKAGE Clp_columnLower(Clp_Simplex *model)
Column Lower.
ClpSolve
This is a very simple class to guide algorithms.
Definition: ClpSolve.hpp:20
Clp_dropNames
COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex *model)
Drops names - makes lengthnames 0 and names empty.
Clp_Simplex
void Clp_Simplex
User does not need to see structure of model but C++ code does.
Definition: Coin_C_defines.h:59
Clp_getObjCoefficients
COINLIBAPI const double *COINLINKAGE Clp_getObjCoefficients(Clp_Simplex *model)
Objective.
Clp_problemName
COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex *model, int maxNumberCharacters, char *array)
Fills in array with problem name.
Clp_VersionMinor
COINLIBAPI int COINLINKAGE Clp_VersionMinor(void)
Minor number of Clp library version.
Clp_isPrimalObjectiveLimitReached
COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex *model)
Is the given primal objective limit reached?
Clp_copyinStatus
COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex *model, const unsigned char *statusArray)
Copy in status vector.
Clp_getRowActivity
COINLIBAPI const double *COINLINKAGE Clp_getRowActivity(Clp_Simplex *model)
Primal row solution.
Clp_getColLower
COINLIBAPI const double *COINLINKAGE Clp_getColLower(Clp_Simplex *model)
Column Lower.
ClpSolve_delete
COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve *solve)
Destructor.
Clp_VersionMajor
COINLIBAPI int COINLINKAGE Clp_VersionMajor(void)
Major number of Clp library version.
Clp_setRowName
COINLIBAPI void COINLINKAGE Clp_setRowName(Clp_Simplex *model, int iRow, char *name)
Set row name - Nice if they are short - 8 chars or less I think.
Clp_maximumSeconds
COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex *model)
Maximum time in seconds (from when set called)
Clp_rowName
COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex *model, int iRow, char *name)
Fill in array (at least lengthNames+1 long) with a row name.
Clp_readMps
COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex *model, const char *filename, int keepNames, int ignoreErrors)
Read an mps file from the given filename.
Clp_numberIterations
COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex *model)
Number of iterations.
ClpSolve_doDual
COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *)
Clp_scalingFlag
COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex *model)
Gets scalingFlag.
Clp_integerInformation
COINLIBAPI char *COINLINKAGE Clp_integerInformation(Clp_Simplex *model)
Integer information.
Clp_addRows
COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex *model, int number, const double *rowLower, const double *rowUpper, const CoinBigIndex *rowStarts, const int *columns, const double *elements)
Add rows.
Clp_initialPrimalSolve
COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex *model)
Primal initial solve.
Clp_algorithm
COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex *model)
Current (or last) algorithm.
ClpSolve_setPresolveActions
COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action)
Clp_isProvenPrimalInfeasible
COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex *model)
Is primal infeasiblity proven?
Clp_unboundedRay
COINLIBAPI double *COINLINKAGE Clp_unboundedRay(Clp_Simplex *model)
Gives ray in which the problem is unbounded.
ClpSolve_doDupcol
COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *)
Clp_setColSolution
COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex *model, const double *input)
ClpSolve_new
COINLIBAPI Clp_Solve *COINLINKAGE ClpSolve_new()
Default constructor.
Clp_numberColumns
COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex *model)
Number of columns.
Clp_dualObjectiveLimit
COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex *model)
Dual objective limit.
Clp_getObjValue
COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex *model)
Objective value.
Clp_dualRowSolution
COINLIBAPI double *COINLINKAGE Clp_dualRowSolution(Clp_Simplex *model)
Dual row solution.
Clp_getRowLower
COINLIBAPI const double *COINLINKAGE Clp_getRowLower(Clp_Simplex *model)
Row lower.
ClpSolve_doSingleton
COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *)
Clp_clearCallBack
COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex *model)
Unset Callback function.
ClpSolve_setDoDuprow
COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow)
Clp_columnName
COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex *model, int iColumn, char *name)
Fill in array (at least lengthNames+1 long) with a column name.
Clp_setOptimizationDirection
COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex *model, double value)
Clp_restoreModel
COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex *model, const char *fileName)
Restore model from file, returns 0 if success, deletes current model.
ClpSolve_getPresolveType
COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *)
COINLINKAGE
#define COINLINKAGE
Definition: Coin_C_defines.h:45
Clp_rowLower
COINLIBAPI double *COINLINKAGE Clp_rowLower(Clp_Simplex *model)
Row lower.
Clp_newModel
COINLIBAPI Clp_Simplex *COINLINKAGE Clp_newModel(void)
Default constructor.
Clp_initialSolve
COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex *model)
General solve algorithm which can do presolve.
Clp_secondaryStatus
COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex *model)
Secondary status of problem - may get extended 0 - none 1 - primal infeasible because dual limit reac...
Clp_dualTolerance
COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex *model)
Dual tolerance to use.
Clp_numberRows
COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex *model)
Number of rows.
Clp_setMaximumIterations
COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex *model, int value)
Clp_objective
COINLIBAPI double *COINLINKAGE Clp_objective(Clp_Simplex *model)
Objective.
Clp_setSecondaryStatus
COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex *model, int status)
Clp_isProvenDualInfeasible
COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex *model)
Is dual infeasiblity proven?
ClpSolve_setSubstitution
COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value)
Clp_setObjSense
COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex *model, double objsen)
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Clp_getElements
COINLIBAPI const double *COINLINKAGE Clp_getElements(Clp_Simplex *model)
Clp_setSmallElementValue
COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex *model, double value)
Clp_objectiveValue
COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex *model)
Objective value.
Clp_primalFeasible
COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex *model)
If problem is primal feasible.
Clp_chgRowLower
COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex *model, const double *rowLower)
Change row lower bounds.
ClpSolve_doDuprow
COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *)
Clp_getRowUpper
COINLIBAPI const double *COINLINKAGE Clp_getRowUpper(Clp_Simplex *model)
Row upper.
Clp_setColumnStatus
COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex *model, int sequence, int value)
Clp_getVectorLengths
COINLIBAPI const int *COINLINKAGE Clp_getVectorLengths(Clp_Simplex *model)
ClpSolve_setSolveType
COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo)
method: (see ClpSolve::SolveType) 0 - dual simplex 1 - primal simplex 2 - primal or sprint 3 - barrie...
Clp_getNumRows
COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex *model)
Number of rows.
Clp_columnUpper
COINLIBAPI double *COINLINKAGE Clp_columnUpper(Clp_Simplex *model)
Column Upper.
Clp_primal
COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex *model, int ifValuesPass)
Primal algorithm - see ClpSimplexPrimal.hpp for method.
Clp_statusArray
COINLIBAPI unsigned char *COINLINKAGE Clp_statusArray(Clp_Simplex *model)
Return address of status array (char[numberRows+numberColumns])
Clp_isAbandoned
COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex *model)
Are there a numerical difficulties?
Clp_chgColumnUpper
COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex *model, const double *columnUpper)
Change column upper bounds.
Clp_sumPrimalInfeasibilities
COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex *model)
Sum of primal infeasibilities.
Clp_isDualObjectiveLimitReached
COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex *model)
Is the given dual objective limit reached?
Clp_VersionRelease
COINLIBAPI int COINLINKAGE Clp_VersionRelease(void)
Release number of Clp library version.
Clp_getRowPrice
COINLIBAPI const double *COINLINKAGE Clp_getRowPrice(Clp_Simplex *model)
Dual row solution.
ClpSolve_getPresolvePasses
COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *)
Clp_getReducedCost
COINLIBAPI const double *COINLINKAGE Clp_getReducedCost(Clp_Simplex *model)
Reduced costs.
Clp_chgObjCoefficients
COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex *model, const double *objIn)
Change objective coefficients.
Clp_primalColumnSolution
COINLIBAPI double *COINLINKAGE Clp_primalColumnSolution(Clp_Simplex *model)
Primal column solution.
Clp_getColUpper
COINLIBAPI const double *COINLINKAGE Clp_getColUpper(Clp_Simplex *model)
Column Upper.
Clp_copyInIntegerInformation
COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex *model, const char *information)
Copy in integer informations.
ClpSolve_setSpecialOption
COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo)
Clp_setPrimalTolerance
COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex *model, double value)
Clp_printModel
COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex *model, const char *prefix)
Print model for debugging purposes.
ClpSolve_substitution
COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *)
Clp_rowUpper
COINLIBAPI double *COINLINKAGE Clp_rowUpper(Clp_Simplex *model)
Row upper.
Clp_lengthNames
COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex *model)
length of names (0 means no names0
Clp_perturbation
COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex *model)
Perturbation: 50 - switch on perturbation 100 - auto perturb if takes too long (1.0e-6 largest nonzero) 101 - we are perturbed 102 - don&#39;t try perturbing again default is 100 others are for playing.
Clp_getIndices
COINLIBAPI const int *COINLINKAGE Clp_getIndices(Clp_Simplex *model)
COINLIBAPI
#define COINLIBAPI
This has #defines etc for the &quot;C&quot; interface to Coin.
Definition: Coin_C_defines.h:43
Coin_C_defines.h
Clp_getColSolution
COINLIBAPI const double *COINLINKAGE Clp_getColSolution(Clp_Simplex *model)
Primal column solution.
Clp_dualBound
COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex *model)
Dual bound.
Clp_setProblemStatus
COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex *model, int problemStatus)
Set problem status.
ClpSolve_doSingletonColumn
COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *)
Clp_deleteIntegerInformation
COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex *model)
Drop integer informations.
Clp_hitMaximumIterations
COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex *model)
Returns true if hit maximum iterations (or time)
Clp_setDualTolerance
COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex *model, double value)
Clp_getSmallElementValue
COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex *model)
ClpSolve_doTripleton
COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *)
Clp_getObjSense
COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex *model)
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Clp_saveModel
COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex *model, const char *fileName)
Save model to file, returns 0 if success.
Clp_setColumnName
COINLIBAPI void COINLINKAGE Clp_setColumnName(Clp_Simplex *model, int iColumn, char *name)
Set column name - Nice if they are short - 8 chars or less I think.
Clp_getColumnStatus
COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex *model, int sequence)
Clp_writeMps
COINLIBAPI int COINLINKAGE Clp_writeMps(Clp_Simplex *model, const char *filename, int formatType, int numberAcross, double objSense)
Write an mps file to the given filename.
Clp_setAlgorithm
COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex *model, int value)
Set algorithm.
ClpSolve_setDoDoubleton
COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton)
Clp_scaling
COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex *model, int mode)
Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) ...
Clp_getUserPointer
COINLIBAPI void *COINLINKAGE Clp_getUserPointer(Clp_Simplex *model)
Clp_initialDualSolve
COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex *model)
Dual initial solve.
Clp_loadQuadraticObjective
COINLIBAPI void COINLINKAGE Clp_loadQuadraticObjective(Clp_Simplex *model, const int numberColumns, const CoinBigIndex *start, const int *column, const double *element)
Clp_resize
COINLIBAPI void COINLINKAGE Clp_resize(Clp_Simplex *model, int newNumberRows, int newNumberColumns)
Resizes rim part of model.
maximumIterations
COINLIBAPI int maximumIterations(Clp_Simplex *model)
Maximum number of iterations.
Clp_checkSolution
COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex *model)
Just check solution (for external use) - sets sum of infeasibilities etc.
ClpSolve_doTighten
COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *)
Clp_dualColumnSolution
COINLIBAPI double *COINLINKAGE Clp_dualColumnSolution(Clp_Simplex *model)
Reduced costs.
Clp_chgColumnLower
COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex *model, const double *columnLower)
Change column lower bounds.
Clp_initialSolveWithOptions
COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex *model, Clp_Solve *)
Pass solve options.
ClpSolve_setDoSingleton
COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton)
Clp_chgRowUpper
COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex *model, const double *rowUpper)
Change row upper bounds.
ClpSolve_setDoSingletonColumn
COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton)
clp_callback
void(COINLINKAGE_CB * clp_callback)(Clp_Simplex *model, int msgno, int ndouble, const double *dvec, int nint, const int *ivec, int nchar, char **cvec)
typedef for user call back.
Definition: Coin_C_defines.h:66
Clp_copyNames
COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex *model, const char *const *rowNames, const char *const *columnNames)
Copies in names.
Clp_getVectorStarts
COINLIBAPI const CoinBigIndex *COINLINKAGE Clp_getVectorStarts(Clp_Simplex *model)
Clp_sumDualInfeasibilities
COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex *model)
Sum of dual infeasibilities.
ClpSolve_doImpliedFree
COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *)
Clp_infeasibilityRay
COINLIBAPI double *COINLINKAGE Clp_infeasibilityRay(Clp_Simplex *model)
Gives Infeasibility ray.
Clp_numberDualInfeasibilities
COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex *model)
Number of dual infeasibilities.
Clp_statusExists
COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex *model)
See if status array exists (partly for OsiClp)
Clp_dual
COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex *model, int ifValuesPass)
Dual algorithm - see ClpSimplexDual.hpp for method.
Clp_primalRowSolution
COINLIBAPI double *COINLINKAGE Clp_primalRowSolution(Clp_Simplex *model)
Primal row solution.
Clp_modifyCoefficient
COINLIBAPI void COINLINKAGE Clp_modifyCoefficient(Clp_Simplex *model, int row, int column, double newElement, bool keepZero)
Change matrix coefficients.
Clp_setMaximumSeconds
COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex *model, double value)
Clp_setDualBound
COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex *model, double value)
Clp_setUserPointer
COINLIBAPI void COINLINKAGE Clp_setUserPointer(Clp_Simplex *model, void *pointer)
User pointer for whatever reason.
ClpSolve_infeasibleReturn
COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *)
Clp_setLogLevel
COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex *model, int value)
Amount of print out: 0 - none 1 - just final 2 - just factorizations 3 - as 2 plus a bit more 4 - ver...
ClpSolve_setDoTripleton
COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton)
ClpSolve_setInfeasibleReturn
COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse)
Clp_deleteModel
COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex *model)
Destructor.
Clp_objectiveOffset
COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex *model)
Objective offset.
Clp_status
COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex *model)
Status of problem: 0 - optimal 1 - primal infeasible 2 - dual infeasible 3 - stopped on iterations et...
CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:136
Clp_getNumCols
COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex *model)
Number of columns.
Clp_registerCallBack
COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex *model, clp_callback userCallBack)
Pass in Callback function.
Clp_getRowStatus
COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex *model, int sequence)
Clp_logLevel
COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex *model)
Clp_setInfeasibilityCost
COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex *model, double value)
Clp_getIterationCount
COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex *model)
Number of iterations.
Clp_initialBarrierNoCrossSolve
COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex *model)
Barrier initial solve, no crossover.
Clp_crash
COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex *model, double gap, int pivot)
Crash - at present just aimed at dual, returns -2 if dual preferred and crash basis created -1 if dua...
ClpSolve_setDoDual
COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual)
ClpSolve_setDoImpliedFree
COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree)
Clp_isProvenOptimal
COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex *model)
Is optimality proven?
ClpSolve_getSolveType
COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *)
Clp_Solve
void Clp_Solve
Definition: Clp_C_Interface.h:19
Clp_Version
COINLIBAPI const char *COINLINKAGE Clp_Version(void)
Clp library version number as string.
Clp_setNumberIterations
COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex *model, int numberIterations)
ClpSolve_doDoubleton
COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *)
Clp_getNumElements
COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex *model)
Number of elements in matrix.
Clp_idiot
COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex *model, int tryhard)
Solve the problem with the idiot code.
ClpSolve_setPresolveType
COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo)
amount: (see ClpSolve::PresolveType) 0 - presolve on 1 - presolve off 2 - presolve number 3 - presolv...
ClpSolve_setDoForcing
COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing)
Clp_numberPrimalInfeasibilities
COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex *model)
Number of primal infeasibilities.
ClpSolve_setDoDupcol
COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol)
Clp_setProblemName
COINLIBAPI int COINLINKAGE Clp_setProblemName(Clp_Simplex *model, int maxNumberCharacters, char *array)
Clp_deleteRows
COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex *model, int number, const int *which)
Deletes rows.
Clp_initialBarrierSolve
COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex *model)
Barrier initial solve.
ClpSolve_presolveActions
COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *)
Clp_dualFeasible
COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex *model)
If problem is dual feasible.
Clp_setRowStatus
COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex *model, int sequence, int value)
ClpSolve_setDoTighten
COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten)
ClpSolve_getExtraInfo
COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which)
Clp_primalTolerance
COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex *model)
Primal tolerance to use.
ClpSolve_doForcing
COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *)
Clp_setObjectiveOffset
COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex *model, double value)
ClpSolve_getSpecialOption
COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which)
Clp_optimizationDirection
COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex *model)
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Clp_setPerturbation
COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex *model, int value)
Clp_setDualObjectiveLimit
COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex *model, double value)
Clp_loadProblem
COINLIBAPI void COINLINKAGE Clp_loadProblem(Clp_Simplex *model, const int numcols, const int numrows, const CoinBigIndex *start, const int *index, const double *value, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub)
Loads a problem (the constraints on the rows are given by lower and upper bounds).
Clp_addColumns
COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex *model, int number, const double *columnLower, const double *columnUpper, const double *objective, const CoinBigIndex *columnStarts, const int *rows, const double *elements)
Add columns.
Clp_isIterationLimitReached
COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex *model)
Iteration limit reached?
Clp_infeasibilityCost
COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex *model)
Infeasibility cost.
Clp_freeRay
COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex *model, double *ray)
Frees a infeasibility or unbounded ray.