source: trunk/Clp/src/Clp_C_Interface.h @ 2030

Last change on this file since 2030 was 2019, checked in by stefan, 6 years ago

add function Clp_freeRay to C interface to free a ray given by Clp_infeasibility/unboundedRay; add functions to get Clp version number from library

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 25.8 KB
Line 
1/* $Id: Clp_C_Interface.h 2019 2014-01-31 05:18:01Z forrest $ */
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. */
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        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 */
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         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). */
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 int * 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 int * 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         0 - optimal
181         1 - primal infeasible
182         2 - dual infeasible
183         3 - stopped on iterations etc
184         4 - stopped due to errors
185     */
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         0 - none
191         1 - primal infeasible because dual limit reached
192         2 - scaled problem optimal - unscaled has primal infeasibilities
193         3 - scaled problem optimal - unscaled has dual infeasibilities
194         4 - scaled problem optimal - unscaled has both dual and primal infeasibilities
195     */
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 int 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      *
235      * Use Clp_freeRay to free the returned array.
236      *
237      * @return infeasibility ray, or NULL returned if none/wrong.
238      */
239     COINLIBAPI double * COINLINKAGE Clp_infeasibilityRay(Clp_Simplex * model);
240     /** Gives ray in which the problem is unbounded.
241      *
242      * Use Clp_freeRay to free the returned array.
243      *
244      * @return unbounded ray, or NULL returned if none/wrong.
245      */
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        3 at lower, 4 superbasic, (5 fixed) */
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      Message numbers up to 1000000 are Clp, Coin ones have 1000000 added */
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         0 - none
282         1 - just final
283         2 - just factorizations
284         3 - as 2 plus a bit more
285         4 - verbose
286         above that 8,16,32 etc just for selective debug
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.
303         See  ClpSolve.hpp for options
304      */
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     /** Dual initial solve */
309     COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex * model);
310     /** Primal initial solve */
311     COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex * model);
312     /** Barrier initial solve */
313     COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex * model);
314     /** Barrier initial solve, no crossover */
315     COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex * model);
316     /** Dual algorithm - see ClpSimplexDual.hpp for method */
317     COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex * model, int ifValuesPass);
318     /** Primal algorithm - see ClpSimplexPrimal.hpp for method */
319     COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex * model, int ifValuesPass);
320#ifndef SLIM_CLP
321     /** Solve the problem with the idiot code */
322     COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex * model, int tryhard);
323#endif
324     /** Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) */
325     COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex * model, int mode);
326     /** Gets scalingFlag */
327     COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex * model);
328     /** Crash - at present just aimed at dual, returns
329         -2 if dual preferred and crash basis created
330         -1 if dual preferred and all slack basis preferred
331          0 if basis going in was not all slack
332          1 if primal preferred and all slack basis preferred
333          2 if primal preferred and crash basis created.
334
335          if gap between bounds <="gap" variables can be flipped
336
337          If "pivot" is
338          0 No pivoting (so will just be choice of algorithm)
339          1 Simple pivoting e.g. gub
340          2 Mini iterations
341     */
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:
359         50  - switch on perturbation
360         100 - auto perturb if takes too long (1.0e-6 largest nonzero)
361         101 - we are perturbed
362         102 - don't try perturbing again
363         default is 100
364         others are for playing
365     */
366     COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex * model);
367     COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex * model, int value);
368     /** Current (or last) algorithm */
369     COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex * model);
370     /** Set algorithm */
371     COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex * model, int value);
372     /** Sum of dual infeasibilities */
373     COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex * model);
374     /** Number of dual infeasibilities */
375     COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex * model);
376     /** Sum of primal infeasibilities */
377     COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex * model);
378     /** Number of primal infeasibilities */
379     COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex * model);
380     /** Save model to file, returns 0 if success.  This is designed for
381         use outside algorithms so does not save iterating arrays etc.
382     It does not save any messaging information.
383     Does not save scaling values.
384     It does not know about all types of virtual functions.
385     */
386     COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex * model, const char * fileName);
387     /** Restore model from file, returns 0 if success,
388         deletes current model */
389     COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex * model, const char * fileName);
390
391     /** Just check solution (for external use) - sets sum of
392         infeasibilities etc */
393     COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex * model);
394     /*@}*/
395
396     /******************** End of most useful part **************/
397     /**@name gets and sets - some synonyms */
398     /*@{*/
399     /** Number of rows */
400     COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex * model);
401     /** Number of columns */
402     COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex * model);
403     /** Number of iterations */
404     COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex * model);
405     /** Are there a numerical difficulties? */
406     COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex * model);
407     /** Is optimality proven? */
408     COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex * model);
409     /** Is primal infeasiblity proven? */
410     COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex * model);
411     /** Is dual infeasiblity proven? */
412     COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex * model);
413     /** Is the given primal objective limit reached? */
414     COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex * model) ;
415     /** Is the given dual objective limit reached? */
416     COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex * model) ;
417     /** Iteration limit reached? */
418     COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex * model);
419     /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
420     COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex * model);
421     /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
422     COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex * model, double objsen);
423     /** Primal row solution */
424     COINLIBAPI const double * COINLINKAGE Clp_getRowActivity(Clp_Simplex * model);
425     /** Primal column solution */
426     COINLIBAPI const double * COINLINKAGE Clp_getColSolution(Clp_Simplex * model);
427     COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex * model, const double * input);
428     /** Dual row solution */
429     COINLIBAPI const double * COINLINKAGE Clp_getRowPrice(Clp_Simplex * model);
430     /** Reduced costs */
431     COINLIBAPI const double * COINLINKAGE Clp_getReducedCost(Clp_Simplex * model);
432     /** Row lower */
433     COINLIBAPI const double* COINLINKAGE Clp_getRowLower(Clp_Simplex * model);
434     /** Row upper  */
435     COINLIBAPI const double* COINLINKAGE Clp_getRowUpper(Clp_Simplex * model);
436     /** Objective */
437     COINLIBAPI const double * COINLINKAGE Clp_getObjCoefficients(Clp_Simplex * model);
438     /** Column Lower */
439     COINLIBAPI const double * COINLINKAGE Clp_getColLower(Clp_Simplex * model);
440     /** Column Upper */
441     COINLIBAPI const double * COINLINKAGE Clp_getColUpper(Clp_Simplex * model);
442     /** Objective value */
443     COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex * model);
444     /** Print model for debugging purposes */
445     COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex * model, const char * prefix);
446     /* Small element value - elements less than this set to zero,
447        default is 1.0e-20 */
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)
460         0 - dual simplex
461         1 - primal simplex
462         2 - primal or sprint
463         3 - barrier
464         4 - barrier no crossover
465         5 - automatic
466         6 - not implemented
467       -- pass extraInfo == -1 for default behavior */
468     COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo);
469     COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *);
470
471     /** amount: (see ClpSolve::PresolveType)
472         0 - presolve on
473         1 - presolve off
474         2 - presolve number
475         3 - presolve number cost
476       -- pass extraInfo == -1 for default behavior */
477     COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo);
478     COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *);
479
480     COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *);
481     COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which);
482     COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse);
483     COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *);
484
485     COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *);
486     COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual);
487
488     COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *);
489     COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton);
490
491     COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *);
492     COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton);
493
494     COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *);
495     COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton);
496
497     COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *);
498     COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten);
499
500     COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *);
501     COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing);
502
503     COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *);
504     COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree);
505     
506     COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *);
507     COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol);
508     
509     COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *);
510     COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow);
511
512     COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *);
513     COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton);
514
515     COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *);
516     COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action);
517
518     COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *);
519     COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value);
520
521     /*@}*/
522#ifdef __cplusplus
523}
524#endif
525#endif
Note: See TracBrowser for help on using the repository browser.