Clp 1.17.5
Loading...
Searching...
No Matches
Clp_C_Interface.h
Go to the documentation of this file.
1/* $Id: Clp_C_Interface.h 2630 2020-01-29 17:45:31Z 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/* accidentally used a bool for Clp_modifyCoefficient, so need to include stdbool.h
15 * Clp_modifyCoefficient signature will change to use int with Clp 1.18
16 * stdbool.h is available with C99
17 * __STDC_VERSION__ isn't available when compiling C++ - look at C++ version instead
18 */
19#if (defined(__cplusplus) && __cplusplus >= 199901L) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
20#include <stdbool.h>
21#endif
22
23#if defined(CLP_EXTERN_C)
24typedef struct {
25 ClpSolve options;
26} Clp_Solve;
27#else
28typedef void Clp_Solve;
29#endif
30
36#ifdef __cplusplus
37extern "C" {
38#endif
39
49COINLIBAPI const char *COINLINKAGE Clp_Version(void);
51COINLIBAPI int COINLINKAGE Clp_VersionMajor(void);
53COINLIBAPI int COINLINKAGE Clp_VersionMinor(void);
55COINLIBAPI int COINLINKAGE Clp_VersionRelease(void);
71
73COINLIBAPI Clp_Simplex *COINLINKAGE Clp_newModel(void);
75COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex *model);
77COINLIBAPI Clp_Solve *COINLINKAGE ClpSolve_new();
79COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve *solve);
97COINLIBAPI void COINLINKAGE Clp_loadProblem(Clp_Simplex *model, const int numcols, const int numrows,
98 const CoinBigIndex *start, const int *index,
99 const double *value,
100 const double *collb, const double *colub,
101 const double *obj,
102 const double *rowlb, const double *rowub);
103
104/* read quadratic part of the objective (the matrix part) */
105COINLIBAPI void COINLINKAGE
106Clp_loadQuadraticObjective(Clp_Simplex *model,
107 const int numberColumns,
108 const CoinBigIndex *start,
109 const int *column,
110 const double *element);
112COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex *model, const char *filename,
113 int keepNames,
114 int ignoreErrors);
119COINLIBAPI int COINLINKAGE Clp_writeMps(Clp_Simplex *model, const char *filename,
120 int formatType,
121 int numberAcross,
122 double objSense);
124COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex *model, const char *information);
126COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex *model);
128COINLIBAPI void COINLINKAGE Clp_resize(Clp_Simplex *model, int newNumberRows, int newNumberColumns);
130COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex *model, int number, const int *which);
132COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex *model, int number, const double *rowLower,
133 const double *rowUpper,
134 const CoinBigIndex *rowStarts, const int *columns,
135 const double *elements);
136
138COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex *model, int number, const int *which);
140COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex *model, int number, const double *columnLower,
141 const double *columnUpper,
142 const double *objective,
143 const CoinBigIndex *columnStarts, const int *rows,
144 const double *elements);
146COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex *model, const double *rowLower);
148COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex *model, const double *rowUpper);
150COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex *model, const double *columnLower);
152COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex *model, const double *columnUpper);
154COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex *model, const double *objIn);
159#if (defined(__cplusplus) && __cplusplus >= 199901L) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
160COINLIBAPI void COINLINKAGE Clp_modifyCoefficient(Clp_Simplex *model, int row, int column, double newElement,
161 bool keepZero);
162#endif
164COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex *model);
166COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex *model, const char *const *rowNames,
167 const char *const *columnNames);
168
173COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex *model);
175COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex *model);
177COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex *model);
178COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex *model, double value);
180COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex *model);
181COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex *model, double value);
183COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex *model);
184COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex *model, double value);
186COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex *model);
187COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex *model, double value);
189COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex *model, int maxNumberCharacters, char *array);
190/* Sets problem name. Must have \0 at end. */
191COINLIBAPI int COINLINKAGE
192Clp_setProblemName(Clp_Simplex *model, int maxNumberCharacters, char *array);
194COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex *model);
195COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex *model, int numberIterations);
197COINLIBAPI int maximumIterations(Clp_Simplex *model);
198COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex *model, int value);
200COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex *model);
201COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex *model, double value);
203COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex *model);
211COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex *model);
213COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex *model, int problemStatus);
221COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex *model);
222COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex *model, int status);
224COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex *model);
225COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex *model, double value);
227COINLIBAPI double *COINLINKAGE Clp_primalRowSolution(Clp_Simplex *model);
229COINLIBAPI double *COINLINKAGE Clp_primalColumnSolution(Clp_Simplex *model);
231COINLIBAPI double *COINLINKAGE Clp_dualRowSolution(Clp_Simplex *model);
233COINLIBAPI double *COINLINKAGE Clp_dualColumnSolution(Clp_Simplex *model);
235COINLIBAPI double *COINLINKAGE Clp_rowLower(Clp_Simplex *model);
237COINLIBAPI double *COINLINKAGE Clp_rowUpper(Clp_Simplex *model);
239COINLIBAPI double *COINLINKAGE Clp_objective(Clp_Simplex *model);
241COINLIBAPI double *COINLINKAGE Clp_columnLower(Clp_Simplex *model);
243COINLIBAPI double *COINLINKAGE Clp_columnUpper(Clp_Simplex *model);
245COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex *model);
246/* Column starts in matrix */
247COINLIBAPI const CoinBigIndex *COINLINKAGE Clp_getVectorStarts(Clp_Simplex *model);
248/* Row indices in matrix */
249COINLIBAPI const int *COINLINKAGE Clp_getIndices(Clp_Simplex *model);
250/* Column vector lengths in matrix */
251COINLIBAPI const int *COINLINKAGE Clp_getVectorLengths(Clp_Simplex *model);
252/* Element values in matrix */
253COINLIBAPI const double *COINLINKAGE Clp_getElements(Clp_Simplex *model);
255COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex *model);
257COINLIBAPI char *COINLINKAGE Clp_integerInformation(Clp_Simplex *model);
264COINLIBAPI double *COINLINKAGE Clp_infeasibilityRay(Clp_Simplex *model);
271COINLIBAPI double *COINLINKAGE Clp_unboundedRay(Clp_Simplex *model);
273COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex *model, double *ray);
275COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex *model);
277COINLIBAPI unsigned char *COINLINKAGE Clp_statusArray(Clp_Simplex *model);
279COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex *model, const unsigned char *statusArray);
280/* status values are as in ClpSimplex.hpp i.e. 0 - free, 1 basic, 2 at upper,
281 3 at lower, 4 superbasic, (5 fixed) */
282/* Get variable basis info */
283COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex *model, int sequence);
284/* Get row basis info */
285COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex *model, int sequence);
286/* Set variable basis info (and value if at bound) */
287COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex *model,
288 int sequence, int value);
289/* Set row basis info (and value if at bound) */
290COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex *model,
291 int sequence, int value);
292
294COINLIBAPI void COINLINKAGE Clp_setUserPointer(Clp_Simplex *model, void *pointer);
295COINLIBAPI void *COINLINKAGE Clp_getUserPointer(Clp_Simplex *model);
301COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex *model,
302 clp_callback userCallBack);
304COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex *model);
313COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex *model, int value);
314COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex *model);
316COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex *model);
318COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex *model, int iRow, char *name);
320COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex *model, int iColumn, char *name);
322COINLIBAPI void COINLINKAGE Clp_setRowName(Clp_Simplex *model, int iRow, char *name);
324COINLIBAPI void COINLINKAGE Clp_setColumnName(Clp_Simplex *model, int iColumn, char *name);
325
333COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex *model);
335COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex *model, Clp_Solve *);
337COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex *model);
339COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex *model);
341COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex *model);
343COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex *model);
345COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex *model, int ifValuesPass);
347COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex *model, int ifValuesPass);
348#ifndef SLIM_CLP
350COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex *model, int tryhard);
351#endif
353COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex *model, int mode);
355COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex *model);
370COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex *model, double gap, int pivot);
376COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex *model);
378COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex *model);
380COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex *model);
381COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex *model, double value);
383COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex *model);
384COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex *model, double value);
393COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex *model);
394COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex *model, int value);
396COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex *model);
398COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex *model, int value);
400COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex *model);
402COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex *model);
404COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex *model);
406COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex *model);
413COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex *model, const char *fileName);
416COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex *model, const char *fileName);
417
420COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex *model);
423/******************** End of most useful part **************/
427COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex *model);
429COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex *model);
431COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex *model);
433COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex *model);
435COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex *model);
437COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex *model);
439COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex *model);
441COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex *model);
443COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex *model);
445COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex *model);
447COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex *model);
449COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex *model, double objsen);
451COINLIBAPI const double *COINLINKAGE Clp_getRowActivity(Clp_Simplex *model);
453COINLIBAPI const double *COINLINKAGE Clp_getColSolution(Clp_Simplex *model);
454COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex *model, const double *input);
456COINLIBAPI const double *COINLINKAGE Clp_getRowPrice(Clp_Simplex *model);
458COINLIBAPI const double *COINLINKAGE Clp_getReducedCost(Clp_Simplex *model);
460COINLIBAPI const double *COINLINKAGE Clp_getRowLower(Clp_Simplex *model);
462COINLIBAPI const double *COINLINKAGE Clp_getRowUpper(Clp_Simplex *model);
464COINLIBAPI const double *COINLINKAGE Clp_getObjCoefficients(Clp_Simplex *model);
466COINLIBAPI const double *COINLINKAGE Clp_getColLower(Clp_Simplex *model);
468COINLIBAPI const double *COINLINKAGE Clp_getColUpper(Clp_Simplex *model);
470COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex *model);
472COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex *model, const char *prefix);
473/* Small element value - elements less than this set to zero,
474 default is 1.0e-20 */
475COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex *model);
476COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex *model, double value);
482COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo);
483COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which);
484
494COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo);
495COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *);
496
503COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo);
504COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *);
505
506COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *);
507COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which);
508COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse);
509COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *);
510
511COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *);
512COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual);
513
514COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *);
515COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton);
516
517COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *);
518COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton);
519
520COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *);
521COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton);
522
523COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *);
524COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten);
525
526COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *);
527COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing);
528
529COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *);
530COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree);
531
532COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *);
533COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol);
534
535COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *);
536COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow);
537
538COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *);
539COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton);
540
541COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *);
542COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action);
543
544COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *);
545COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value);
546
548#ifdef __cplusplus
549}
550#endif
551#endif
552
553/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
554*/
COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *)
COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex *model)
Sum of dual infeasibilities.
COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex *model)
Objective offset.
COINLIBAPI const double *COINLINKAGE Clp_getRowLower(Clp_Simplex *model)
Row lower.
COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex *model)
COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton)
COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex *model)
Barrier initial solve.
COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex *model, const double *rowLower)
Change row lower bounds.
COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *)
COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex *model, const unsigned char *statusArray)
Copy in status vector.
COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex *model, double value)
COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex *model)
Dual bound.
COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex *model)
length of names (0 means no names0
COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex *model, int tryhard)
Solve the problem with the idiot code.
COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *)
COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex *model, int ifValuesPass)
Dual algorithm - see ClpSimplexDual.hpp for method.
COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex *model, double value)
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...
COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex *model)
Objective value.
COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex *model, const char *fileName)
Save model to file, returns 0 if success.
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)
COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex *model, double objsen)
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex *model)
COINLIBAPI int maximumIterations(Clp_Simplex *model)
Maximum number of iterations.
COINLIBAPI const int *COINLINKAGE Clp_getIndices(Clp_Simplex *model)
COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex *model)
Current (or last) algorithm.
COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *)
COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex *model)
Are there a numerical difficulties?
COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *)
COINLIBAPI const double *COINLINKAGE Clp_getColLower(Clp_Simplex *model)
Column Lower.
COINLIBAPI Clp_Solve *COINLINKAGE ClpSolve_new()
Default constructor.
COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex *model)
Dual initial solve.
COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *)
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...
COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex *model, const char *fileName)
Restore model from file, returns 0 if success, deletes current model.
COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex *model, const char *filename, int keepNames, int ignoreErrors)
Read an mps file from the given filename.
COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex *model, const char *information)
Copy in integer informations.
COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex *model)
Is optimality proven?
COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which)
COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action)
COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex *model)
Number of elements in matrix.
COINLIBAPI double *COINLINKAGE Clp_infeasibilityRay(Clp_Simplex *model)
Gives Infeasibility ray.
COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex *model)
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex *model)
Returns true if hit maximum iterations (or time)
COINLIBAPI const double *COINLINKAGE Clp_getReducedCost(Clp_Simplex *model)
Reduced costs.
COINLIBAPI double *COINLINKAGE Clp_dualRowSolution(Clp_Simplex *model)
Dual row solution.
COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex *model, int value)
COINLIBAPI int COINLINKAGE Clp_VersionMajor(void)
Major number of Clp library version.
COINLIBAPI const double *COINLINKAGE Clp_getRowUpper(Clp_Simplex *model)
Row upper
COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex *model)
Iteration limit reached?
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).
COINLIBAPI double *COINLINKAGE Clp_rowUpper(Clp_Simplex *model)
Row upper
COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex *model, int number, const int *which)
Deletes rows.
COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex *model, int sequence, int value)
COINLIBAPI double *COINLINKAGE Clp_unboundedRay(Clp_Simplex *model)
Gives ray in which the problem is unbounded.
COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex *model)
Primal tolerance to use.
COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex *model)
See if status array exists (partly for OsiClp)
COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex *model)
Number of primal infeasibilities.
COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex *model)
Is primal infeasiblity proven?
COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo)
COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol)
COINLIBAPI double *COINLINKAGE Clp_primalColumnSolution(Clp_Simplex *model)
Primal column solution.
COINLIBAPI double *COINLINKAGE Clp_columnUpper(Clp_Simplex *model)
Column Upper.
COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex *model)
If problem is primal feasible.
COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex *model, int iColumn, char *name)
Fill in array (at least lengthNames+1 long) with a column name.
COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex *model)
Unset Callback function.
COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex *model)
Objective value.
COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex *model)
Sum of primal infeasibilities.
COINLIBAPI int COINLINKAGE Clp_setProblemName(Clp_Simplex *model, int maxNumberCharacters, char *array)
COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex *model, const double *objIn)
Change objective coefficients.
COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *)
COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex *model, const double *input)
COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex *model, double value)
COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual)
COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex *model, double value)
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.
COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *)
COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex *model)
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
COINLIBAPI int COINLINKAGE Clp_VersionMinor(void)
Minor number of Clp library version.
COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex *model, double value)
COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex *model)
Perturbation: 50 - switch on perturbation 100 - auto perturb if takes too long (1....
COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex *model, int maxNumberCharacters, char *array)
Fills in array with problem name
COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex *model)
Just check solution (for external use) - sets sum of infeasibilities etc.
COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing)
COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex *model, double value)
COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton)
COINLIBAPI const int *COINLINKAGE Clp_getVectorLengths(Clp_Simplex *model)
COINLIBAPI double *COINLINKAGE Clp_rowLower(Clp_Simplex *model)
Row lower.
COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex *model)
If problem is dual feasible.
COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *)
COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex *model, int value)
Set algorithm.
COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *)
COINLIBAPI const double *COINLINKAGE Clp_getObjCoefficients(Clp_Simplex *model)
Objective.
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.
COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex *model)
Infeasibility cost.
COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex *model)
Is the given primal objective limit reached?
COINLIBAPI const double *COINLINKAGE Clp_getRowPrice(Clp_Simplex *model)
Dual row solution.
COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex *model)
Number of rows.
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...
COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex *model, int sequence, int value)
COINLIBAPI int COINLINKAGE Clp_VersionRelease(void)
Release number of Clp library version.
COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex *model)
Number of rows.
COINLIBAPI const double *COINLINKAGE Clp_getRowActivity(Clp_Simplex *model)
Primal row solution.
COINLIBAPI double *COINLINKAGE Clp_columnLower(Clp_Simplex *model)
Column Lower.
COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex *model)
Status of problem: 0 - optimal 1 - primal infeasible 2 - dual infeasible 3 - stopped on iterations et...
COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex *model, double value)
COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex *model)
Number of iterations.
COINLIBAPI const double *COINLINKAGE Clp_getColUpper(Clp_Simplex *model)
Column Upper.
COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value)
COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex *model)
Number of iterations.
COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex *model, double value)
COINLIBAPI void COINLINKAGE Clp_resize(Clp_Simplex *model, int newNumberRows, int newNumberColumns)
Resizes rim part of model
COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow)
COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex *model, int numberIterations)
COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex *model, int problemStatus)
Set problem status.
COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex *model, int iRow, char *name)
Fill in array (at least lengthNames+1 long) with a row name.
COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex *model, int sequence)
COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *)
COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which)
COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex *model)
Number of dual infeasibilities.
COINLIBAPI double *COINLINKAGE Clp_dualColumnSolution(Clp_Simplex *model)
Reduced costs.
COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex *model)
Is dual infeasiblity proven?
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.
COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex *model, int status)
COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *)
COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex *model, Clp_Solve *)
Pass solve options.
COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex *model, double value)
COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex *model)
Secondary status of problem - may get extended 0 - none 1 - primal infeasible because dual limit reac...
COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve *solve)
Destructor.
COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton)
COINLIBAPI const double *COINLINKAGE Clp_getColSolution(Clp_Simplex *model)
Primal column solution.
COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex *model)
Barrier initial solve, no crossover.
COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex *model)
Dual objective limit.
COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex *model, const char *const *rowNames, const char *const *columnNames)
Copies in names.
COINLIBAPI void COINLINKAGE Clp_loadQuadraticObjective(Clp_Simplex *model, const int numberColumns, const CoinBigIndex *start, const int *column, const double *element)
COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse)
COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex *model, int number, const int *which)
Deletes columns.
COINLIBAPI void COINLINKAGE Clp_setUserPointer(Clp_Simplex *model, void *pointer)
User pointer for whatever reason.
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.
COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *)
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.
COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *)
COINLIBAPI double *COINLINKAGE Clp_objective(Clp_Simplex *model)
Objective.
COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex *model)
Destructor.
COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex *model)
Number of columns.
COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex *model, int sequence)
COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex *model, double *ray)
Frees a infeasibility or unbounded ray.
COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten)
COINLIBAPI char *COINLINKAGE Clp_integerInformation(Clp_Simplex *model)
Integer information.
COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex *model, const double *columnLower)
Change column lower bounds.
COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex *model, int value)
COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex *model)
Maximum time in seconds (from when set called)
COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex *model)
General solve algorithm which can do presolve.
COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton)
COINLIBAPI void *COINLINKAGE Clp_getUserPointer(Clp_Simplex *model)
COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex *model, const double *rowUpper)
Change row upper bounds.
COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex *model)
Is the given dual objective limit reached?
COINLIBAPI double *COINLINKAGE Clp_primalRowSolution(Clp_Simplex *model)
Primal row solution.
COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex *model)
Gets scalingFlag.
COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex *model, const char *prefix)
Print model for debugging purposes.
COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex *model, const double *columnUpper)
Change column upper bounds.
COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *)
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...
COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex *model, int ifValuesPass)
Primal algorithm - see ClpSimplexPrimal.hpp for method.
COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *)
COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex *model)
Number of columns.
COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex *model)
Change matrix coefficients.
COINLIBAPI const CoinBigIndex *COINLINKAGE Clp_getVectorStarts(Clp_Simplex *model)
COINLIBAPI const char *COINLINKAGE Clp_Version(void)
Clp library version number as string.
COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex *model)
Dual tolerance to use.
COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex *model, clp_callback userCallBack)
Pass in Callback function.
COINLIBAPI unsigned char *COINLINKAGE Clp_statusArray(Clp_Simplex *model)
Return address of status array (char[numberRows+numberColumns])
COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex *model)
Primal initial solve.
COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree)
void Clp_Solve
COINLIBAPI const double *COINLINKAGE Clp_getElements(Clp_Simplex *model)
COINLIBAPI Clp_Simplex *COINLINKAGE Clp_newModel(void)
Default constructor.
COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex *model)
Drop integer informations.
This is a very simple class to guide algorithms.
Definition ClpSolve.hpp:20