Changeset 2385 for trunk/Clp/src/Clp_C_Interface.h
 Timestamp:
 Jan 6, 2019 2:43:06 PM (3 months ago)
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

trunk/Clp/src/Clp_C_Interface.h
r2271 r2385 12 12 #include "Coin_C_defines.h" 13 13 14 #if defined 14 #if defined(CLP_EXTERN_C) 15 15 typedef struct { 16 16 ClpSolve options; … … 29 29 #endif 30 30 31 31 /**@name Version info 32 32 * 33 33 * A Clp library has a version number of the form <major>.<minor>.<release>, … … 36 36 * For a checkout of the Clp development branch, major, minor, and release are 9999. 37 37 */ 38 39 40 COINLIBAPI const char*COINLINKAGE Clp_Version(void);41 42 43 44 45 46 47 48 49 38 /*@{*/ 39 /** Clp library version number as string. */ 40 COINLIBAPI const char *COINLINKAGE Clp_Version(void); 41 /** Major number of Clp library version. */ 42 COINLIBAPI int COINLINKAGE Clp_VersionMajor(void); 43 /** Minor number of Clp library version. */ 44 COINLIBAPI int COINLINKAGE Clp_VersionMinor(void); 45 /** Release number of Clp library version. */ 46 COINLIBAPI int COINLINKAGE Clp_VersionRelease(void); 47 /*@}*/ 48 49 /**@name Constructors and destructor 50 50 These do not have an exact analogue in C++. 51 51 The user does not need to know structure of Clp_Simplex or Clp_Solve. … … 59 59 from name and applying the method to an object of type ClpSolve. 60 60 */ 61 62 63 64 COINLIBAPI Clp_Simplex *COINLINKAGE Clp_newModel(void);65 66 COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex *model);67 68 COINLIBAPI Clp_Solve *COINLINKAGE ClpSolve_new();69 /** Destructor */ 70 COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve *solve);71 72 73 74 75 61 /*@{*/ 62 63 /** Default constructor */ 64 COINLIBAPI Clp_Simplex *COINLINKAGE Clp_newModel(void); 65 /** Destructor */ 66 COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex *model); 67 /** Default constructor */ 68 COINLIBAPI Clp_Solve *COINLINKAGE ClpSolve_new(); 69 /** Destructor */ 70 COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve *solve); 71 /*@}*/ 72 73 /**@name Load model  loads some stuff and initializes others */ 74 /*@{*/ 75 /** Loads a problem (the constraints on the 76 76 rows are given by lower and upper bounds). If a pointer is NULL then the 77 77 following values are the default: … … 84 84 </ul> 85 85 */ 86 86 /** Just like the other loadProblem() method except that the matrix is 87 87 given in a standard column major ordered format (without gaps). */ 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 96 97 Clp_loadQuadraticObjective(Clp_Simplex *model,98 99 const CoinBigIndex *start,100 const int *column,101 const double *element);102 103 COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex *model, const char *filename,104 105 106 107 COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex * model, const char *information);108 109 COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex *model);110 111 COINLIBAPI void COINLINKAGE Clp_resize (Clp_Simplex *model, int newNumberRows, int newNumberColumns);112 113 COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex * model, int number, const int *which);114 115 COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex * model, int number, const double *rowLower,116 const double *rowUpper,117 const CoinBigIndex * rowStarts, const int *columns,118 const double *elements);119 120 121 COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex * model, int number, const int *which);122 123 COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex * model, int number, const double *columnLower,124 const double *columnUpper,125 const double *objective,126 const CoinBigIndex * columnStarts, const int *rows,127 const double *elements);128 129 COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex * model, const double *rowLower);130 131 COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex * model, const double *rowUpper);132 133 COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex * model, const double *columnLower);134 135 COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex * model, const double *columnUpper);136 137 COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex * model, const double *objIn);138 139 COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex *model);140 141 COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex * model, const char * const *rowNames,142 const char * const *columnNames);143 144 145 146 147 148 COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex *model);149 150 COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex *model);151 152 COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex *model);153 COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex * model, double value);154 155 COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex *model);156 COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex * model, double value);157 158 COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex *model);159 COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex *model, double value);160 161 COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex *model);162 COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex *model, double value);163 164 COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex * model, int maxNumberCharacters, char *array);165 166 167 Clp_setProblemName(Clp_Simplex * model, int maxNumberCharacters, char *array);168 169 COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex *model);170 COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex *model, int numberIterations);171 172 COINLIBAPI int maximumIterations(Clp_Simplex *model);173 COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex *model, int value);174 175 COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex *model);176 COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex *model, double value);177 178 COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex *model);179 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); 102 /** Read an mps file from the given filename */ 103 COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex *model, const char *filename, 104 int keepNames, 105 int ignoreErrors); 106 /** Copy in integer informations */ 107 COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex *model, const char *information); 108 /** Drop integer informations */ 109 COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex *model); 110 /** Resizes rim part of model */ 111 COINLIBAPI void COINLINKAGE Clp_resize(Clp_Simplex *model, int newNumberRows, int newNumberColumns); 112 /** Deletes rows */ 113 COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex *model, int number, const int *which); 114 /** Add rows */ 115 COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex *model, int number, const double *rowLower, 116 const double *rowUpper, 117 const CoinBigIndex *rowStarts, const int *columns, 118 const double *elements); 119 120 /** Deletes columns */ 121 COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex *model, int number, const int *which); 122 /** Add columns */ 123 COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex *model, int number, const double *columnLower, 124 const double *columnUpper, 125 const double *objective, 126 const CoinBigIndex *columnStarts, const int *rows, 127 const double *elements); 128 /** Change row lower bounds */ 129 COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex *model, const double *rowLower); 130 /** Change row upper bounds */ 131 COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex *model, const double *rowUpper); 132 /** Change column lower bounds */ 133 COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex *model, const double *columnLower); 134 /** Change column upper bounds */ 135 COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex *model, const double *columnUpper); 136 /** Change objective coefficients */ 137 COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex *model, const double *objIn); 138 /** Drops names  makes lengthnames 0 and names empty */ 139 COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex *model); 140 /** Copies in names */ 141 COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex *model, const char *const *rowNames, 142 const char *const *columnNames); 143 144 /*@}*/ 145 /**@name gets and sets  you will find some synonyms at the end of this file */ 146 /*@{*/ 147 /** Number of rows */ 148 COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex *model); 149 /** Number of columns */ 150 COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex *model); 151 /** Primal tolerance to use */ 152 COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex *model); 153 COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex *model, double value); 154 /** Dual tolerance to use */ 155 COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex *model); 156 COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex *model, double value); 157 /** Dual objective limit */ 158 COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex *model); 159 COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex *model, double value); 160 /** Objective offset */ 161 COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex *model); 162 COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex *model, double value); 163 /** Fills in array with problem name */ 164 COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex *model, int maxNumberCharacters, char *array); 165 /* Sets problem name. Must have \0 at end. */ 166 COINLIBAPI int COINLINKAGE 167 Clp_setProblemName(Clp_Simplex *model, int maxNumberCharacters, char *array); 168 /** Number of iterations */ 169 COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex *model); 170 COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex *model, int numberIterations); 171 /** Maximum number of iterations */ 172 COINLIBAPI int maximumIterations(Clp_Simplex *model); 173 COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex *model, int value); 174 /** Maximum time in seconds (from when set called) */ 175 COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex *model); 176 COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex *model, double value); 177 /** Returns true if hit maximum iterations (or time) */ 178 COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex *model); 179 /** Status of problem: 180 180 0  optimal 181 181 1  primal infeasible … … 184 184 4  stopped due to errors 185 185 */ 186 COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex *model);187 188 COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex *model, int problemStatus);189 186 COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex *model); 187 /** Set problem status */ 188 COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex *model, int problemStatus); 189 /** Secondary status of problem  may get extended 190 190 0  none 191 191 1  primal infeasible because dual limit reached … … 194 194 4  scaled problem optimal  unscaled has both dual and primal infeasibilities 195 195 */ 196 COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex *model);197 COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex *model, int status);198 199 COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex *model);200 COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex *model, double value);201 202 COINLIBAPI double * COINLINKAGE Clp_primalRowSolution(Clp_Simplex *model);203 204 COINLIBAPI double * COINLINKAGE Clp_primalColumnSolution(Clp_Simplex *model);205 206 COINLIBAPI double * COINLINKAGE Clp_dualRowSolution(Clp_Simplex *model);207 208 COINLIBAPI double * COINLINKAGE Clp_dualColumnSolution(Clp_Simplex *model);209 210 COINLIBAPI double* COINLINKAGE Clp_rowLower(Clp_Simplex *model);211 212 COINLIBAPI double* COINLINKAGE Clp_rowUpper(Clp_Simplex *model);213 214 COINLIBAPI double * COINLINKAGE Clp_objective(Clp_Simplex *model);215 216 COINLIBAPI double * COINLINKAGE Clp_columnLower(Clp_Simplex *model);217 218 COINLIBAPI double * COINLINKAGE Clp_columnUpper(Clp_Simplex *model);219 220 COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex *model);221 222 COINLIBAPI const CoinBigIndex * COINLINKAGE Clp_getVectorStarts(Clp_Simplex *model);223 224 COINLIBAPI const int * COINLINKAGE Clp_getIndices(Clp_Simplex *model);225 226 COINLIBAPI const int * COINLINKAGE Clp_getVectorLengths(Clp_Simplex *model);227 228 COINLIBAPI const double * COINLINKAGE Clp_getElements(Clp_Simplex *model);229 230 COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex *model);231 232 COINLIBAPI char * COINLINKAGE Clp_integerInformation(Clp_Simplex *model);233 196 COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex *model); 197 COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex *model, int status); 198 /** Direction of optimization (1  minimize, 1  maximize, 0  ignore */ 199 COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex *model); 200 COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex *model, double value); 201 /** Primal row solution */ 202 COINLIBAPI double *COINLINKAGE Clp_primalRowSolution(Clp_Simplex *model); 203 /** Primal column solution */ 204 COINLIBAPI double *COINLINKAGE Clp_primalColumnSolution(Clp_Simplex *model); 205 /** Dual row solution */ 206 COINLIBAPI double *COINLINKAGE Clp_dualRowSolution(Clp_Simplex *model); 207 /** Reduced costs */ 208 COINLIBAPI double *COINLINKAGE Clp_dualColumnSolution(Clp_Simplex *model); 209 /** Row lower */ 210 COINLIBAPI double *COINLINKAGE Clp_rowLower(Clp_Simplex *model); 211 /** Row upper */ 212 COINLIBAPI double *COINLINKAGE Clp_rowUpper(Clp_Simplex *model); 213 /** Objective */ 214 COINLIBAPI double *COINLINKAGE Clp_objective(Clp_Simplex *model); 215 /** Column Lower */ 216 COINLIBAPI double *COINLINKAGE Clp_columnLower(Clp_Simplex *model); 217 /** Column Upper */ 218 COINLIBAPI double *COINLINKAGE Clp_columnUpper(Clp_Simplex *model); 219 /** Number of elements in matrix */ 220 COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex *model); 221 /* Column starts in matrix */ 222 COINLIBAPI const CoinBigIndex *COINLINKAGE Clp_getVectorStarts(Clp_Simplex *model); 223 /* Row indices in matrix */ 224 COINLIBAPI const int *COINLINKAGE Clp_getIndices(Clp_Simplex *model); 225 /* Column vector lengths in matrix */ 226 COINLIBAPI const int *COINLINKAGE Clp_getVectorLengths(Clp_Simplex *model); 227 /* Element values in matrix */ 228 COINLIBAPI const double *COINLINKAGE Clp_getElements(Clp_Simplex *model); 229 /** Objective value */ 230 COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex *model); 231 /** Integer information */ 232 COINLIBAPI char *COINLINKAGE Clp_integerInformation(Clp_Simplex *model); 233 /** Gives Infeasibility ray. 234 234 * 235 235 * Use Clp_freeRay to free the returned array. … … 237 237 * @return infeasibility ray, or NULL returned if none/wrong. 238 238 */ 239 COINLIBAPI double * COINLINKAGE Clp_infeasibilityRay(Clp_Simplex *model);240 239 COINLIBAPI double *COINLINKAGE Clp_infeasibilityRay(Clp_Simplex *model); 240 /** Gives ray in which the problem is unbounded. 241 241 * 242 242 * Use Clp_freeRay to free the returned array. … … 244 244 * @return unbounded ray, or NULL returned if none/wrong. 245 245 */ 246 COINLIBAPI double * COINLINKAGE Clp_unboundedRay(Clp_Simplex *model);247 248 COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex * model, double *ray);249 250 COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex *model);251 252 COINLIBAPI unsigned char * COINLINKAGE Clp_statusArray(Clp_Simplex *model);253 254 COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex * model, const unsigned char *statusArray);255 246 COINLIBAPI double *COINLINKAGE Clp_unboundedRay(Clp_Simplex *model); 247 /** Frees a infeasibility or unbounded ray. */ 248 COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex *model, double *ray); 249 /** See if status array exists (partly for OsiClp) */ 250 COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex *model); 251 /** Return address of status array (char[numberRows+numberColumns]) */ 252 COINLIBAPI unsigned char *COINLINKAGE Clp_statusArray(Clp_Simplex *model); 253 /** Copy in status vector */ 254 COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex *model, const unsigned char *statusArray); 255 /* status values are as in ClpSimplex.hpp i.e. 0  free, 1 basic, 2 at upper, 256 256 3 at lower, 4 superbasic, (5 fixed) */ 257 258 COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex *model, int sequence);259 260 COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex *model, int sequence);261 262 COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex *model,263 264 265 COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex *model,266 267 268 269 COINLIBAPI void COINLINKAGE Clp_setUserPointer (Clp_Simplex * model, void *pointer);270 COINLIBAPI void * COINLINKAGE Clp_getUserPointer (Clp_Simplex *model);271 272 273 274 257 /* Get variable basis info */ 258 COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex *model, int sequence); 259 /* Get row basis info */ 260 COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex *model, int sequence); 261 /* Set variable basis info (and value if at bound) */ 262 COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex *model, 263 int sequence, int value); 264 /* Set row basis info (and value if at bound) */ 265 COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex *model, 266 int sequence, int value); 267 268 /** User pointer for whatever reason */ 269 COINLIBAPI void COINLINKAGE Clp_setUserPointer(Clp_Simplex *model, void *pointer); 270 COINLIBAPI void *COINLINKAGE Clp_getUserPointer(Clp_Simplex *model); 271 /*@}*/ 272 /**@name Message handling. Call backs are handled by ONE function */ 273 /*@{*/ 274 /** Pass in Callback function. 275 275 Message numbers up to 1000000 are Clp, Coin ones have 1000000 added */ 276 COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex *model,277 278 279 COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex *model);280 276 COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex *model, 277 clp_callback userCallBack); 278 /** Unset Callback function */ 279 COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex *model); 280 /** Amount of print out: 281 281 0  none 282 282 1  just final … … 286 286 above that 8,16,32 etc just for selective debug 287 287 */ 288 COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex * model, int value); 289 COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex * model); 290 /** length of names (0 means no names0 */ 291 COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex * model); 292 /** Fill in array (at least lengthNames+1 long) with a row name */ 293 COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex * model, int iRow, char * name); 294 /** Fill in array (at least lengthNames+1 long) with a column name */ 295 COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex * model, int iColumn, char * name); 296 297 /*@}*/ 298 299 300 /**@name Functions most useful to user */ 301 /*@{*/ 302 /** General solve algorithm which can do presolve. 288 COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex *model, int value); 289 COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex *model); 290 /** length of names (0 means no names0 */ 291 COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex *model); 292 /** Fill in array (at least lengthNames+1 long) with a row name */ 293 COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex *model, int iRow, char *name); 294 /** Fill in array (at least lengthNames+1 long) with a column name */ 295 COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex *model, int iColumn, char *name); 296 297 /*@}*/ 298 299 /**@name Functions most useful to user */ 300 /*@{*/ 301 /** General solve algorithm which can do presolve. 303 302 See ClpSolve.hpp for options 304 303 */ 305 COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex *model);306 /** Pass solve options. (Exception to direct analogue rule) */ 307 COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex *model, Clp_Solve *);308 309 COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex *model);310 311 COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex *model);312 313 COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex *model);314 315 COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex *model);316 317 COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex *model, int ifValuesPass);318 319 COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex *model, int ifValuesPass);304 COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex *model); 305 /** Pass solve options. (Exception to direct analogue rule) */ 306 COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex *model, Clp_Solve *); 307 /** Dual initial solve */ 308 COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex *model); 309 /** Primal initial solve */ 310 COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex *model); 311 /** Barrier initial solve */ 312 COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex *model); 313 /** Barrier initial solve, no crossover */ 314 COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex *model); 315 /** Dual algorithm  see ClpSimplexDual.hpp for method */ 316 COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex *model, int ifValuesPass); 317 /** Primal algorithm  see ClpSimplexPrimal.hpp for method */ 318 COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex *model, int ifValuesPass); 320 319 #ifndef SLIM_CLP 321 322 COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex *model, int tryhard);320 /** Solve the problem with the idiot code */ 321 COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex *model, int tryhard); 323 322 #endif 324 325 COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex *model, int mode);326 327 COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex *model);328 323 /** Sets or unsets scaling, 0 off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) */ 324 COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex *model, int mode); 325 /** Gets scalingFlag */ 326 COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex *model); 327 /** Crash  at present just aimed at dual, returns 329 328 2 if dual preferred and crash basis created 330 329 1 if dual preferred and all slack basis preferred … … 340 339 2 Mini iterations 341 340 */ 342 COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex * model, double gap, int pivot); 343 /*@}*/ 344 345 346 /**@name most useful gets and sets */ 347 /*@{*/ 348 /** If problem is primal feasible */ 349 COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex * model); 350 /** If problem is dual feasible */ 351 COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex * model); 352 /** Dual bound */ 353 COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex * model); 354 COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex * model, double value); 355 /** Infeasibility cost */ 356 COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex * model); 357 COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex * model, double value); 358 /** Perturbation: 341 COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex *model, double gap, int pivot); 342 /*@}*/ 343 344 /**@name most useful gets and sets */ 345 /*@{*/ 346 /** If problem is primal feasible */ 347 COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex *model); 348 /** If problem is dual feasible */ 349 COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex *model); 350 /** Dual bound */ 351 COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex *model); 352 COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex *model, double value); 353 /** Infeasibility cost */ 354 COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex *model); 355 COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex *model, double value); 356 /** Perturbation: 359 357 50  switch on perturbation 360 358 100  auto perturb if takes too long (1.0e6 largest nonzero) … … 364 362 others are for playing 365 363 */ 366 COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex *model);367 COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex *model, int value);368 369 COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex *model);370 371 COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex *model, int value);372 373 COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex *model);374 375 COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex *model);376 377 COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex *model);378 379 COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex *model);380 364 COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex *model); 365 COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex *model, int value); 366 /** Current (or last) algorithm */ 367 COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex *model); 368 /** Set algorithm */ 369 COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex *model, int value); 370 /** Sum of dual infeasibilities */ 371 COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex *model); 372 /** Number of dual infeasibilities */ 373 COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex *model); 374 /** Sum of primal infeasibilities */ 375 COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex *model); 376 /** Number of primal infeasibilities */ 377 COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex *model); 378 /** Save model to file, returns 0 if success. This is designed for 381 379 use outside algorithms so does not save iterating arrays etc. 382 380 It does not save any messaging information. … … 384 382 It does not know about all types of virtual functions. 385 383 */ 386 COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex * model, const char *fileName);387 384 COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex *model, const char *fileName); 385 /** Restore model from file, returns 0 if success, 388 386 deletes current model */ 389 COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex * model, const char *fileName);390 391 387 COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex *model, const char *fileName); 388 389 /** Just check solution (for external use)  sets sum of 392 390 infeasibilities etc */ 393 COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex *model);394 395 396 397 398 399 400 COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex *model);401 402 COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex *model);403 404 COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex *model);405 406 COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex *model);407 408 COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex *model);409 410 COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex *model);411 412 COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex *model);413 414 COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex * model);415 416 COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex * model);417 418 COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex *model);419 420 COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex *model);421 422 COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex *model, double objsen);423 424 COINLIBAPI const double * COINLINKAGE Clp_getRowActivity(Clp_Simplex *model);425 426 COINLIBAPI const double * COINLINKAGE Clp_getColSolution(Clp_Simplex *model);427 COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex * model, const double *input);428 429 COINLIBAPI const double * COINLINKAGE Clp_getRowPrice(Clp_Simplex *model);430 431 COINLIBAPI const double * COINLINKAGE Clp_getReducedCost(Clp_Simplex *model);432 433 COINLIBAPI const double* COINLINKAGE Clp_getRowLower(Clp_Simplex *model);434 435 COINLIBAPI const double* COINLINKAGE Clp_getRowUpper(Clp_Simplex *model);436 437 COINLIBAPI const double * COINLINKAGE Clp_getObjCoefficients(Clp_Simplex *model);438 439 COINLIBAPI const double * COINLINKAGE Clp_getColLower(Clp_Simplex *model);440 441 COINLIBAPI const double * COINLINKAGE Clp_getColUpper(Clp_Simplex *model);442 443 COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex *model);444 445 COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex * model, const char *prefix);446 391 COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex *model); 392 /*@}*/ 393 394 /******************** End of most useful part **************/ 395 /**@name gets and sets  some synonyms */ 396 /*@{*/ 397 /** Number of rows */ 398 COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex *model); 399 /** Number of columns */ 400 COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex *model); 401 /** Number of iterations */ 402 COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex *model); 403 /** Are there a numerical difficulties? */ 404 COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex *model); 405 /** Is optimality proven? */ 406 COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex *model); 407 /** Is primal infeasiblity proven? */ 408 COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex *model); 409 /** Is dual infeasiblity proven? */ 410 COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex *model); 411 /** Is the given primal objective limit reached? */ 412 COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex *model); 413 /** Is the given dual objective limit reached? */ 414 COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex *model); 415 /** Iteration limit reached? */ 416 COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex *model); 417 /** Direction of optimization (1  minimize, 1  maximize, 0  ignore */ 418 COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex *model); 419 /** Direction of optimization (1  minimize, 1  maximize, 0  ignore */ 420 COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex *model, double objsen); 421 /** Primal row solution */ 422 COINLIBAPI const double *COINLINKAGE Clp_getRowActivity(Clp_Simplex *model); 423 /** Primal column solution */ 424 COINLIBAPI const double *COINLINKAGE Clp_getColSolution(Clp_Simplex *model); 425 COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex *model, const double *input); 426 /** Dual row solution */ 427 COINLIBAPI const double *COINLINKAGE Clp_getRowPrice(Clp_Simplex *model); 428 /** Reduced costs */ 429 COINLIBAPI const double *COINLINKAGE Clp_getReducedCost(Clp_Simplex *model); 430 /** Row lower */ 431 COINLIBAPI const double *COINLINKAGE Clp_getRowLower(Clp_Simplex *model); 432 /** Row upper */ 433 COINLIBAPI const double *COINLINKAGE Clp_getRowUpper(Clp_Simplex *model); 434 /** Objective */ 435 COINLIBAPI const double *COINLINKAGE Clp_getObjCoefficients(Clp_Simplex *model); 436 /** Column Lower */ 437 COINLIBAPI const double *COINLINKAGE Clp_getColLower(Clp_Simplex *model); 438 /** Column Upper */ 439 COINLIBAPI const double *COINLINKAGE Clp_getColUpper(Clp_Simplex *model); 440 /** Objective value */ 441 COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex *model); 442 /** Print model for debugging purposes */ 443 COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex *model, const char *prefix); 444 /* Small element value  elements less than this set to zero, 447 445 default is 1.0e20 */ 448 COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex * model); 449 COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex * model, double value); 450 /*@}*/ 451 452 453 /**@name Get and set ClpSolve options 454 */ 455 /*@{*/ 456 COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo); 457 COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which); 458 459 /** method: (see ClpSolve::SolveType) 446 COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex *model); 447 COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex *model, double value); 448 /*@}*/ 449 450 /**@name Get and set ClpSolve options 451 */ 452 /*@{*/ 453 COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo); 454 COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which); 455 456 /** method: (see ClpSolve::SolveType) 460 457 0  dual simplex 461 458 1  primal simplex … … 466 463 6  not implemented 467 464  pass extraInfo == 1 for default behavior */ 468 469 470 471 465 COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo); 466 COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *); 467 468 /** amount: (see ClpSolve::PresolveType) 472 469 0  presolve on 473 470 1  presolve off … … 475 472 3  presolve number cost 476 473  pass extraInfo == 1 for default behavior */ 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 474 COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo); 475 COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *); 476 477 COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *); 478 COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which); 479 COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse); 480 COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *); 481 482 COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *); 483 COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual); 484 485 COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *); 486 COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton); 487 488 COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *); 489 COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton); 490 491 COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *); 492 COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton); 493 494 COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *); 495 COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten); 496 497 COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *); 498 COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing); 499 500 COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *); 501 COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree); 502 503 COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *); 504 COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol); 505 506 COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *); 507 COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow); 508 509 COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *); 510 COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton); 511 512 COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *); 513 COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action); 514 515 COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *); 516 COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value); 517 518 /*@}*/ 522 519 #ifdef __cplusplus 523 520 } 524 521 #endif 525 522 #endif 523 524 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2 525 */
Note: See TracChangeset
for help on using the changeset viewer.