diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/Clp_C_Interface.h')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/Clp_C_Interface.h | 525 |
1 files changed, 525 insertions, 0 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/Clp_C_Interface.h b/newstructure/thirdparty/linux/include/coin/Clp_C_Interface.h new file mode 100644 index 0000000..b91b2d2 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/Clp_C_Interface.h @@ -0,0 +1,525 @@ +/* $Id: Clp_C_Interface.h 2019 2014-01-31 05:18:01Z stefan $ */ +/* + Copyright (C) 2002, 2003 International Business Machines Corporation + and others. All Rights Reserved. + + This code is licensed under the terms of the Eclipse Public License (EPL). +*/ +#ifndef ClpSimplexC_H +#define ClpSimplexC_H + +/* include all defines and ugly stuff */ +#include "Coin_C_defines.h" + +#if defined (CLP_EXTERN_C) +typedef struct { + ClpSolve options; +} Clp_Solve; +#else +typedef void Clp_Solve; +#endif + +/** This is a first "C" interface to Clp. + It has similarities to the OSL V3 interface + and only has most common functions +*/ + +#ifdef __cplusplus +extern "C" { +#endif + + /**@name Version info + * + * A Clp library has a version number of the form <major>.<minor>.<release>, + * where each of major, minor, and release are nonnegative integers. + * For a checkout of the Clp stable branch, release is 9999. + * For a checkout of the Clp development branch, major, minor, and release are 9999. + */ + /*@{*/ + /** Clp library version number as string. */ + COINLIBAPI const char* COINLINKAGE Clp_Version(void); + /** Major number of Clp library version. */ + COINLIBAPI int COINLINKAGE Clp_VersionMajor(void); + /** Minor number of Clp library version. */ + COINLIBAPI int COINLINKAGE Clp_VersionMinor(void); + /** Release number of Clp library version. */ + COINLIBAPI int COINLINKAGE Clp_VersionRelease(void); + /*@}*/ + + /**@name Constructors and destructor + These do not have an exact analogue in C++. + The user does not need to know structure of Clp_Simplex or Clp_Solve. + + For (almost) all Clp_* functions outside this group there is an exact C++ + analogue created by taking the first parameter out, removing the Clp_ + from name and applying the method to an object of type ClpSimplex. + + Similarly, for all ClpSolve_* functions there is an exact C++ + analogue created by taking the first parameter out, removing the ClpSolve_ + from name and applying the method to an object of type ClpSolve. + */ + /*@{*/ + + /** Default constructor */ + COINLIBAPI Clp_Simplex * COINLINKAGE Clp_newModel(void); + /** Destructor */ + COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex * model); + /** Default constructor */ + COINLIBAPI Clp_Solve * COINLINKAGE ClpSolve_new(); + /** Destructor */ + COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve * solve); + /*@}*/ + + /**@name Load model - loads some stuff and initializes others */ + /*@{*/ + /** 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). */ + 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); + + /* read quadratic part of the objective (the matrix part) */ + COINLIBAPI void COINLINKAGE + Clp_loadQuadraticObjective(Clp_Simplex * model, + const int numberColumns, + const CoinBigIndex * start, + const int * column, + const double * element); + /** Read an mps file from the given filename */ + COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex * model, const char *filename, + int keepNames, + int ignoreErrors); + /** Copy in integer informations */ + COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex * model, const char * information); + /** Drop integer informations */ + COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex * model); + /** Resizes rim part of model */ + COINLIBAPI void COINLINKAGE Clp_resize (Clp_Simplex * model, int newNumberRows, int newNumberColumns); + /** Deletes rows */ + COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex * model, int number, const int * which); + /** Add rows */ + COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex * model, int number, const double * rowLower, + const double * rowUpper, + const int * rowStarts, const int * columns, + const double * elements); + + /** Deletes columns */ + COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex * model, int number, const int * which); + /** Add columns */ + COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex * model, int number, const double * columnLower, + const double * columnUpper, + const double * objective, + const int * columnStarts, const int * rows, + const double * elements); + /** Change row lower bounds */ + COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex * model, const double * rowLower); + /** Change row upper bounds */ + COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex * model, const double * rowUpper); + /** Change column lower bounds */ + COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex * model, const double * columnLower); + /** Change column upper bounds */ + COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex * model, const double * columnUpper); + /** Change objective coefficients */ + COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex * model, const double * objIn); + /** Drops names - makes lengthnames 0 and names empty */ + COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex * model); + /** Copies in names */ + COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex * model, const char * const * rowNames, + const char * const * columnNames); + + /*@}*/ + /**@name gets and sets - you will find some synonyms at the end of this file */ + /*@{*/ + /** Number of rows */ + COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex * model); + /** Number of columns */ + COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex * model); + /** Primal tolerance to use */ + COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex * model, double value) ; + /** Dual tolerance to use */ + COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex * model, double value) ; + /** Dual objective limit */ + COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex * model, double value); + /** Objective offset */ + COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex * model, double value); + /** Fills in array with problem name */ + COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex * model, int maxNumberCharacters, char * array); + /* Sets problem name. Must have \0 at end. */ + COINLIBAPI int COINLINKAGE + Clp_setProblemName(Clp_Simplex * model, int maxNumberCharacters, char * array); + /** Number of iterations */ + COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex * model, int numberIterations); + /** Maximum number of iterations */ + COINLIBAPI int maximumIterations(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex * model, int value); + /** Maximum time in seconds (from when set called) */ + COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex * model, double value); + /** Returns true if hit maximum iterations (or time) */ + COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex * model); + /** Status of problem: + 0 - optimal + 1 - primal infeasible + 2 - dual infeasible + 3 - stopped on iterations etc + 4 - stopped due to errors + */ + COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex * model); + /** Set problem status */ + COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex * model, int problemStatus); + /** 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 + */ + COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex * model, int status); + /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */ + COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex * model, double value); + /** Primal row solution */ + COINLIBAPI double * COINLINKAGE Clp_primalRowSolution(Clp_Simplex * model); + /** Primal column solution */ + COINLIBAPI double * COINLINKAGE Clp_primalColumnSolution(Clp_Simplex * model); + /** Dual row solution */ + COINLIBAPI double * COINLINKAGE Clp_dualRowSolution(Clp_Simplex * model); + /** Reduced costs */ + COINLIBAPI double * COINLINKAGE Clp_dualColumnSolution(Clp_Simplex * model); + /** Row lower */ + COINLIBAPI double* COINLINKAGE Clp_rowLower(Clp_Simplex * model); + /** Row upper */ + COINLIBAPI double* COINLINKAGE Clp_rowUpper(Clp_Simplex * model); + /** Objective */ + COINLIBAPI double * COINLINKAGE Clp_objective(Clp_Simplex * model); + /** Column Lower */ + COINLIBAPI double * COINLINKAGE Clp_columnLower(Clp_Simplex * model); + /** Column Upper */ + COINLIBAPI double * COINLINKAGE Clp_columnUpper(Clp_Simplex * model); + /** Number of elements in matrix */ + COINLIBAPI int COINLINKAGE Clp_getNumElements(Clp_Simplex * model); + /* Column starts in matrix */ + COINLIBAPI const CoinBigIndex * COINLINKAGE Clp_getVectorStarts(Clp_Simplex * model); + /* Row indices in matrix */ + COINLIBAPI const int * COINLINKAGE Clp_getIndices(Clp_Simplex * model); + /* Column vector lengths in matrix */ + COINLIBAPI const int * COINLINKAGE Clp_getVectorLengths(Clp_Simplex * model); + /* Element values in matrix */ + COINLIBAPI const double * COINLINKAGE Clp_getElements(Clp_Simplex * model); + /** Objective value */ + COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex * model); + /** Integer information */ + COINLIBAPI char * COINLINKAGE Clp_integerInformation(Clp_Simplex * model); + /** Gives Infeasibility ray. + * + * Use Clp_freeRay to free the returned array. + * + * @return infeasibility ray, or NULL returned if none/wrong. + */ + COINLIBAPI double * COINLINKAGE Clp_infeasibilityRay(Clp_Simplex * model); + /** Gives ray in which the problem is unbounded. + * + * Use Clp_freeRay to free the returned array. + * + * @return unbounded ray, or NULL returned if none/wrong. + */ + COINLIBAPI double * COINLINKAGE Clp_unboundedRay(Clp_Simplex * model); + /** Frees a infeasibility or unbounded ray. */ + COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex * model, double * ray); + /** See if status array exists (partly for OsiClp) */ + COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex * model); + /** Return address of status array (char[numberRows+numberColumns]) */ + COINLIBAPI unsigned char * COINLINKAGE Clp_statusArray(Clp_Simplex * model); + /** Copy in status vector */ + COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex * model, const unsigned char * statusArray); + /* status values are as in ClpSimplex.hpp i.e. 0 - free, 1 basic, 2 at upper, + 3 at lower, 4 superbasic, (5 fixed) */ + /* Get variable basis info */ + COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex * model, int sequence); + /* Get row basis info */ + COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex * model, int sequence); + /* Set variable basis info (and value if at bound) */ + COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex * model, + int sequence, int value); + /* Set row basis info (and value if at bound) */ + COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex * model, + int sequence, int value); + + /** User pointer for whatever reason */ + COINLIBAPI void COINLINKAGE Clp_setUserPointer (Clp_Simplex * model, void * pointer); + COINLIBAPI void * COINLINKAGE Clp_getUserPointer (Clp_Simplex * model); + /*@}*/ + /**@name Message handling. Call backs are handled by ONE function */ + /*@{*/ + /** Pass in Callback function. + Message numbers up to 1000000 are Clp, Coin ones have 1000000 added */ + COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex * model, + clp_callback userCallBack); + /** Unset Callback function */ + COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex * model); + /** 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 + */ + COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex * model, int value); + COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex * model); + /** length of names (0 means no names0 */ + COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex * model); + /** Fill in array (at least lengthNames+1 long) with a row name */ + COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex * model, int iRow, char * name); + /** Fill in array (at least lengthNames+1 long) with a column name */ + COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex * model, int iColumn, char * name); + + /*@}*/ + + + /**@name Functions most useful to user */ + /*@{*/ + /** General solve algorithm which can do presolve. + See ClpSolve.hpp for options + */ + COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex * model); + /** Pass solve options. (Exception to direct analogue rule) */ + COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex * model, Clp_Solve *); + /** Dual initial solve */ + COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex * model); + /** Primal initial solve */ + COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex * model); + /** Barrier initial solve */ + COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex * model); + /** Barrier initial solve, no crossover */ + COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex * model); + /** Dual algorithm - see ClpSimplexDual.hpp for method */ + COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex * model, int ifValuesPass); + /** Primal algorithm - see ClpSimplexPrimal.hpp for method */ + COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex * model, int ifValuesPass); +#ifndef SLIM_CLP + /** Solve the problem with the idiot code */ + COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex * model, int tryhard); +#endif + /** Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) */ + COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex * model, int mode); + /** Gets scalingFlag */ + COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex * model); + /** 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 + */ + COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex * model, double gap, int pivot); + /*@}*/ + + + /**@name most useful gets and sets */ + /*@{*/ + /** If problem is primal feasible */ + COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex * model); + /** If problem is dual feasible */ + COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex * model); + /** Dual bound */ + COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex * model, double value); + /** Infeasibility cost */ + COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex * model, double value); + /** 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 + */ + COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex * model, int value); + /** Current (or last) algorithm */ + COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex * model); + /** Set algorithm */ + COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex * model, int value); + /** Sum of dual infeasibilities */ + COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex * model); + /** Number of dual infeasibilities */ + COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex * model); + /** Sum of primal infeasibilities */ + COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex * model); + /** Number of primal infeasibilities */ + COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex * model); + /** 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. + */ + COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex * model, const char * fileName); + /** Restore model from file, returns 0 if success, + deletes current model */ + COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex * model, const char * fileName); + + /** Just check solution (for external use) - sets sum of + infeasibilities etc */ + COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex * model); + /*@}*/ + + /******************** End of most useful part **************/ + /**@name gets and sets - some synonyms */ + /*@{*/ + /** Number of rows */ + COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex * model); + /** Number of columns */ + COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex * model); + /** Number of iterations */ + COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex * model); + /** Are there a numerical difficulties? */ + COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex * model); + /** Is optimality proven? */ + COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex * model); + /** Is primal infeasiblity proven? */ + COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex * model); + /** Is dual infeasiblity proven? */ + COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex * model); + /** Is the given primal objective limit reached? */ + COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex * model) ; + /** Is the given dual objective limit reached? */ + COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex * model) ; + /** Iteration limit reached? */ + COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex * model); + /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */ + COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex * model); + /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */ + COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex * model, double objsen); + /** Primal row solution */ + COINLIBAPI const double * COINLINKAGE Clp_getRowActivity(Clp_Simplex * model); + /** Primal column solution */ + COINLIBAPI const double * COINLINKAGE Clp_getColSolution(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex * model, const double * input); + /** Dual row solution */ + COINLIBAPI const double * COINLINKAGE Clp_getRowPrice(Clp_Simplex * model); + /** Reduced costs */ + COINLIBAPI const double * COINLINKAGE Clp_getReducedCost(Clp_Simplex * model); + /** Row lower */ + COINLIBAPI const double* COINLINKAGE Clp_getRowLower(Clp_Simplex * model); + /** Row upper */ + COINLIBAPI const double* COINLINKAGE Clp_getRowUpper(Clp_Simplex * model); + /** Objective */ + COINLIBAPI const double * COINLINKAGE Clp_getObjCoefficients(Clp_Simplex * model); + /** Column Lower */ + COINLIBAPI const double * COINLINKAGE Clp_getColLower(Clp_Simplex * model); + /** Column Upper */ + COINLIBAPI const double * COINLINKAGE Clp_getColUpper(Clp_Simplex * model); + /** Objective value */ + COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex * model); + /** Print model for debugging purposes */ + COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex * model, const char * prefix); + /* Small element value - elements less than this set to zero, + default is 1.0e-20 */ + COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex * model, double value); + /*@}*/ + + + /**@name Get and set ClpSolve options + */ + /*@{*/ + COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo); + COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which); + + /** 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 */ + COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo); + COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *); + + /** amount: (see ClpSolve::PresolveType) + 0 - presolve on + 1 - presolve off + 2 - presolve number + 3 - presolve number cost + -- pass extraInfo == -1 for default behavior */ + COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo); + COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *); + + COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *); + COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which); + COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse); + COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *); + + COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual); + + COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton); + + COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton); + + COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton); + + COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten); + + COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing); + + COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree); + + COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol); + + COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow); + + COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton); + + COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action); + + COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value); + + /*@}*/ +#ifdef __cplusplus +} +#endif +#endif |