source: stable/1.17/Clp/src/Clp_C_Interface.h @ 2449

Last change on this file since 2449 was 2449, checked in by stefan, 3 months ago

sync with trunk

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