source: trunk/Cbc/src/Cbc_C_Interface.h @ 1573

Last change on this file since 1573 was 1573, checked in by lou, 8 years ago

Change to EPL license notice.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.9 KB
Line 
1/* $Id: Cbc_C_Interface.h 1573 2011-01-05 01:12:36Z lou $ */
2/*
3  Copyright (C) 2004 International Business Machines Corporation and others.
4  All Rights Reserved.
5
6  This code is licensed under the terms of the Eclipse Public License (EPL).
7*/
8#ifndef CbcModelC_H
9#define CbcModelC_H
10
11/* include all defines and ugly stuff */
12#include "Coin_C_defines.h"
13
14/** This is a first "C" interface to Cbc.
15    It is mostly similar to the "C" interface to Clp and
16    was contributed by Bob Entriken.
17*/
18
19#ifdef __cplusplus
20extern "C" {
21#endif
22
23    /**@name Constructors and destructor
24       These do not have an exact analogue in C++.
25       The user does not need to know structure of Cbc_Model.
26
27       For all functions outside this group there is an exact C++
28       analogue created by taking the first parameter out, removing the Cbc_
29       from name and applying the method to an object of type ClpSimplex.
30    */
31    /*@{*/
32
33    /** Version */
34    COINLIBAPI double COINLINKAGE Cbc_getVersion()
35    ;
36    /** Default Cbc_Model constructor */
37    COINLIBAPI Cbc_Model * COINLINKAGE
38    Cbc_newModel()
39    ;
40    /** Cbc_Model Destructor */
41    COINLIBAPI void COINLINKAGE
42    Cbc_deleteModel(Cbc_Model * model)
43    ;
44    /*@}*/
45
46    /**@name Load model - loads some stuff and initializes others */
47    /*@{*/
48    /* Loads a problem (the constraints on the
49        rows are given by lower and upper bounds). If a pointer is NULL then the
50        following values are the default:
51        <ul>
52        <li> <code>colub</code>: all columns have upper bound infinity
53        <li> <code>collb</code>: all columns have lower bound 0
54        <li> <code>rowub</code>: all rows have upper bound infinity
55        <li> <code>rowlb</code>: all rows have lower bound -infinity
56        <li> <code>obj</code>: all variables have 0 objective coefficient
57        </ul>
58
59     Just like the other loadProblem() method except that the matrix is
60     given in a standard column major ordered format (without gaps).
61    */
62    COINLIBAPI void COINLINKAGE
63    Cbc_loadProblem (Cbc_Model * model,  const int numcols, const int numrows,
64                     const CoinBigIndex * start, const int* index,
65                     const double* value,
66                     const double* collb, const double* colub,
67                     const double* obj,
68                     const double* rowlb, const double* rowub)
69    ;
70    /** Read an mps file from the given filename */
71    COINLIBAPI int COINLINKAGE
72    Cbc_readMps(Cbc_Model * model, const char *filename)
73    ;
74    /** Write an mps file from the given filename */
75    COINLIBAPI void COINLINKAGE
76    Cbc_writeMps(Cbc_Model * model, const char *filename)
77    ;
78    /** Integer information */
79    COINLIBAPI char * COINLINKAGE
80    Cbc_integerInformation(Cbc_Model * model)
81    ;
82    /** Copy in integer information */
83    COINLIBAPI void COINLINKAGE
84    Cbc_copyInIntegerInformation(Cbc_Model * model, const char * information)
85    ;
86    /** Drop integer informations */
87    COINLIBAPI void COINLINKAGE
88    Cbc_deleteIntegerInformation(Cbc_Model * model)
89    ;
90    /** Resizes rim part of model  */
91    COINLIBAPI void COINLINKAGE
92    Cbc_resize (Cbc_Model * model, int newNumberRows, int newNumberColumns)
93    ;
94    /** Deletes rows */
95    COINLIBAPI void COINLINKAGE
96    Cbc_deleteRows(Cbc_Model * model, int number, const int * which)
97    ;
98    /** Add rows */
99    COINLIBAPI void COINLINKAGE
100    Cbc_addRows(Cbc_Model * model, const int number, const double * rowLower,
101                const double * rowUpper,
102                const int * rowStarts, const int * columns,
103                const double * elements)
104    ;
105
106    /** Deletes columns */
107    COINLIBAPI void COINLINKAGE
108    Cbc_deleteColumns(Cbc_Model * model, int number, const int * which)
109    ;
110    /** Add columns */
111    COINLIBAPI void COINLINKAGE
112    Cbc_addColumns(Cbc_Model * model, int number, const double * columnLower,
113                   const double * columnUpper,
114                   const double * objective,
115                   const int * columnStarts, const int * rows,
116                   const double * elements);
117    /** Drops names - makes lengthnames 0 and names empty */
118    COINLIBAPI void COINLINKAGE
119    Cbc_dropNames(Cbc_Model * model)
120    ;
121    /** Copies in names */
122    COINLIBAPI void COINLINKAGE
123    Cbc_copyNames(Cbc_Model * model, const char * const * rowNamesIn,
124                  const char * const * columnNamesIn)
125    ;
126
127    /*@}*/
128    /**@name gets and sets - you will find some synonyms at the end of this file */
129    /*@{*/
130    /** Number of rows */
131    COINLIBAPI int COINLINKAGE
132    Cbc_numberRows(Cbc_Model * model)
133    ;
134    /** Number of columns */
135    COINLIBAPI int COINLINKAGE
136    Cbc_numberColumns(Cbc_Model * model)
137    ;
138    /** Primal tolerance to use */
139    COINLIBAPI double COINLINKAGE
140    Cbc_primalTolerance(Cbc_Model * model)
141    ;
142    COINLIBAPI void COINLINKAGE
143    Cbc_setPrimalTolerance(Cbc_Model * model,  double value)
144    ;
145    /** Dual tolerance to use */
146    COINLIBAPI double COINLINKAGE
147    Cbc_dualTolerance(Cbc_Model * model)
148    ;
149    COINLIBAPI void COINLINKAGE
150    Cbc_setDualTolerance(Cbc_Model * model,  double value)
151    ;
152    /* Integer tolerance to use */
153    COINLIBAPI double COINLINKAGE
154    Cbc_integerTolerance(Cbc_Model * model)
155    ;
156    COINLIBAPI void COINLINKAGE
157    Cbc_setIntegerTolerance(Cbc_Model * model,  double value)
158    ;
159    /** Dual objective limit */
160    COINLIBAPI double COINLINKAGE
161    Cbc_dualObjectiveLimit(Cbc_Model * model)
162    ;
163    COINLIBAPI void COINLINKAGE
164    Cbc_setDualObjectiveLimit(Cbc_Model * model, double value)
165    ;
166    /** Objective offset */
167    COINLIBAPI double COINLINKAGE
168    Cbc_objectiveOffset(Cbc_Model * model)
169    ;
170    COINLIBAPI void COINLINKAGE
171    Cbc_setObjectiveOffset(Cbc_Model * model, double value)
172    ;
173    /** Fills in array with problem name  */
174    COINLIBAPI void COINLINKAGE
175    Cbc_problemName(Cbc_Model * model, int maxNumberCharacters, char * array)
176    ;
177    /** Sets problem name.  Must have \0 at end.  */
178    COINLIBAPI int COINLINKAGE
179    Cbc_setProblemName(Cbc_Model * model, int maxNumberCharacters, char * array)
180    ;
181    /** Number of iterations */
182    COINLIBAPI int COINLINKAGE
183    Cbc_numberIterations(Cbc_Model * model)
184    ;
185    COINLIBAPI void COINLINKAGE
186    Cbc_setNumberIterations(Cbc_Model * model, int numberIterations)
187    ;
188    /** Maximum number of iterations */
189    COINLIBAPI int COINLINKAGE
190    Cbc_maximumIterations(Cbc_Model * model)
191    ;
192    COINLIBAPI void COINLINKAGE
193    Cbc_setMaximumIterations(Cbc_Model * model, int value)
194    ;
195    /** Maximum number of nodes */
196    COINLIBAPI int COINLINKAGE
197    Cbc_maxNumNode(Cbc_Model * model)
198    ;
199    COINLIBAPI void COINLINKAGE
200    Cbc_setMaxNumNode(Cbc_Model * model, int value)
201    ;
202    /* Maximum number of solutions */
203    COINLIBAPI int COINLINKAGE
204    Cbc_maxNumSol(Cbc_Model * model)
205    ;
206    COINLIBAPI void COINLINKAGE
207    Cbc_setMaxNumSol(Cbc_Model * model, int value)
208    ;
209    /** Maximum time in seconds (from when set called) */
210    COINLIBAPI double COINLINKAGE
211    Cbc_maximumSeconds(Cbc_Model * model)
212    ;
213    COINLIBAPI void COINLINKAGE
214    Cbc_setMaximumSeconds(Cbc_Model * model, double value)
215    ;
216    /** Returns true if hit maximum iterations (or time) */
217    COINLIBAPI int COINLINKAGE
218    Cbc_hitMaximumIterations(Cbc_Model * model)
219    ;
220    /** Status of problem:
221        0 - optimal
222        1 - primal infeasible
223        2 - dual infeasible
224        3 - stopped on iterations etc
225        4 - stopped due to errors
226    */
227    COINLIBAPI int COINLINKAGE
228    Cbc_status(Cbc_Model * model)
229    ;
230    /** Set problem status */
231    COINLIBAPI void COINLINKAGE
232    Cbc_setProblemStatus(Cbc_Model * model, int problemStatus)
233    ;
234    /** Secondary status of problem - may get extended
235        0 - none
236        1 - primal infeasible because dual limit reached
237        2 - scaled problem optimal - unscaled has primal infeasibilities
238        3 - scaled problem optimal - unscaled has dual infeasibilities
239        4 - scaled problem optimal - unscaled has both dual and primal infeasibilities
240    */
241    COINLIBAPI int COINLINKAGE
242    Cbc_secondaryStatus(Cbc_Model * model)
243    ;
244    COINLIBAPI void COINLINKAGE
245    Cbc_setSecondaryStatus(Cbc_Model * model, int status)
246    ;
247    /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
248    COINLIBAPI double COINLINKAGE
249    Cbc_optimizationDirection(Cbc_Model * model)
250    ;
251    COINLIBAPI void COINLINKAGE
252    Cbc_setOptimizationDirection(Cbc_Model * model, double value)
253    ;
254    /** Primal row solution */
255    COINLIBAPI double * COINLINKAGE
256    Cbc_primalRowSolution(Cbc_Model * model)
257    ;
258    /** Primal column solution */
259    COINLIBAPI double * COINLINKAGE
260    Cbc_primalColumnSolution(Cbc_Model * model)
261    ;
262    /** Dual row solution */
263    COINLIBAPI double * COINLINKAGE
264    Cbc_dualRowSolution(Cbc_Model * model)
265    ;
266    /** Reduced costs */
267    COINLIBAPI double * COINLINKAGE
268    Cbc_dualColumnSolution(Cbc_Model * model)
269    ;
270    /** Row lower */
271    COINLIBAPI double* COINLINKAGE
272    Cbc_rowLower(Cbc_Model * model)
273    ;
274    /** Row upper  */
275    COINLIBAPI double* COINLINKAGE
276    Cbc_rowUpper(Cbc_Model * model)
277    ;
278    /** Objective */
279    COINLIBAPI double * COINLINKAGE
280    Cbc_objective(Cbc_Model * model)
281    ;
282    /** Column Lower */
283    COINLIBAPI double * COINLINKAGE
284    Cbc_columnLower(Cbc_Model * model)
285    ;
286    /** Column Upper */
287    COINLIBAPI double * COINLINKAGE
288    Cbc_columnUpper(Cbc_Model * model)
289    ;
290    /** Number of elements in matrix */
291    COINLIBAPI int COINLINKAGE
292    Cbc_getNumElements(Cbc_Model * model)
293    ;
294    /** Column starts in matrix */
295    COINLIBAPI const CoinBigIndex * COINLINKAGE
296    Cbc_getVectorStarts(Cbc_Model * model)
297    ;
298    /** Row indices in matrix */
299    COINLIBAPI const int * COINLINKAGE
300    Cbc_getIndices(Cbc_Model * model)
301    ;
302    /** Column vector lengths in matrix */
303    COINLIBAPI const int * COINLINKAGE
304    Cbc_getVectorLengths(Cbc_Model * model)
305    ;
306    /** Element values in matrix */
307    COINLIBAPI const double * COINLINKAGE
308    Cbc_getElements(Cbc_Model * model)
309    ;
310    /** Objective value */
311    COINLIBAPI double COINLINKAGE
312    Cbc_objectiveValue(Cbc_Model * model)
313    ;
314    /** Infeasibility/unbounded ray (NULL returned if none/wrong)
315        Up to user to use delete [] on these arrays.  */
316    COINLIBAPI double * COINLINKAGE
317    Cbc_infeasibilityRay(Cbc_Model * model)
318    ;
319    COINLIBAPI double * COINLINKAGE
320    Cbc_unboundedRay(Cbc_Model * model)
321    ;
322    /** See if status array exists (partly for OsiClp) */
323    COINLIBAPI int COINLINKAGE
324    Cbc_statusExists(Cbc_Model * model)
325    ;
326    /** Return address of status array (char[numberRows+numberColumns]) */
327    COINLIBAPI void  COINLINKAGE
328    Cbc_getBasisStatus(Cbc_Model * model, int * cstat, int * rstat)
329    ;
330    /** Copy in status vector */
331    COINLIBAPI void COINLINKAGE
332    Cbc_setBasisStatus(Cbc_Model * model, int * cstat, int * rstat)
333    ;
334
335    /** User pointer for whatever reason */
336    COINLIBAPI void COINLINKAGE
337    Cbc_setUserPointer (Cbc_Model * model, void * pointer)
338    ;
339    COINLIBAPI void * COINLINKAGE
340    Cbc_getUserPointer (Cbc_Model * model)
341    ;
342    /*@}*/
343    /**@name Message handling.  Call backs are handled by ONE function */
344    /*@{*/
345    /** Pass in Callback function.
346     Message numbers up to 1000000 are Clp, Coin ones have 1000000 added */
347    COINLIBAPI void COINLINKAGE
348    Cbc_registerCallBack(Cbc_Model * model,
349                         cbc_callback userCallBack)
350    ;
351    /** Unset Callback function */
352    COINLIBAPI void COINLINKAGE
353    Cbc_clearCallBack(Cbc_Model * model)
354    ;
355    /** Amount of print out:
356        0 - none
357        1 - just final
358        2 - just factorizations
359        3 - as 2 plus a bit more
360        4 - verbose
361        above that 8,16,32 etc just for selective debug
362    */
363    COINLIBAPI void COINLINKAGE
364    Cbc_setLogLevel(Cbc_Model * model, int value)
365    ;
366    COINLIBAPI int COINLINKAGE
367    Cbc_logLevel(Cbc_Model * model)
368    ;
369    /** length of names (0 means no names0 */
370    COINLIBAPI int COINLINKAGE
371    Cbc_lengthNames(Cbc_Model * model)
372    ;
373    /** Fill in array (at least lengthNames+1 long) with a row name */
374    COINLIBAPI void COINLINKAGE
375    Cbc_rowName(Cbc_Model * model, int iRow, char * name)
376    ;
377    /** Fill in array (at least lengthNames+1 long) with a column name */
378    COINLIBAPI void COINLINKAGE
379    Cbc_columnName(Cbc_Model * model, int iColumn, char * name)
380    ;
381
382    /*@}*/
383
384
385    /**@name Functions most useful to user */
386    /*@{*/
387    /** General solve algorithm which can do presolve.
388        See  ClpSolve.hpp for options
389     */
390    COINLIBAPI int COINLINKAGE
391    Cbc_initialSolve(Cbc_Model * model)
392    ;
393    /* General solve algorithm which can do presolve.
394       See  CbcModel.hpp for options
395    */
396    COINLIBAPI int COINLINKAGE
397    Cbc_branchAndBound(Cbc_Model * model)
398    ;
399    /** Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) */
400    COINLIBAPI void COINLINKAGE
401    Cbc_scaling(Cbc_Model * model, int mode)
402    ;
403    /** Gets scalingFlag */
404    COINLIBAPI int COINLINKAGE
405    Cbc_scalingFlag(Cbc_Model * model)
406    ;
407    /** Crash - at present just aimed at dual, returns
408        -2 if dual preferred and crash basis created
409        -1 if dual preferred and all slack basis preferred
410         0 if basis going in was not all slack
411         1 if primal preferred and all slack basis preferred
412         2 if primal preferred and crash basis created.
413
414         if gap between bounds <="gap" variables can be flipped
415
416         If "pivot" is
417         0 No pivoting (so will just be choice of algorithm)
418         1 Simple pivoting e.g. gub
419         2 Mini iterations
420    */
421    COINLIBAPI int COINLINKAGE
422    Cbc_crash(Cbc_Model * model, double gap, int pivot)
423    ;
424    /*@}*/
425
426
427    /**@name most useful gets and sets */
428    /*@{*/
429    /** If problem is primal feasible */
430    COINLIBAPI int COINLINKAGE
431    Cbc_primalFeasible(Cbc_Model * model)
432    ;
433    /** If problem is dual feasible */
434    COINLIBAPI int COINLINKAGE
435    Cbc_dualFeasible(Cbc_Model * model)
436    ;
437    /** Dual bound */
438    COINLIBAPI double COINLINKAGE
439    Cbc_dualBound(Cbc_Model * model)
440    ;
441    COINLIBAPI void COINLINKAGE
442    Cbc_setDualBound(Cbc_Model * model, double value)
443    ;
444    /** Infeasibility cost */
445    COINLIBAPI double COINLINKAGE
446    Cbc_infeasibilityCost(Cbc_Model * model)
447    ;
448    COINLIBAPI void COINLINKAGE
449    Cbc_setInfeasibilityCost(Cbc_Model * model, double value)
450    ;
451    /** Perturbation:
452        50  - switch on perturbation
453        100 - auto perturb if takes too long (1.0e-6 largest nonzero)
454        101 - we are perturbed
455        102 - don't try perturbing again
456        default is 100
457        others are for playing
458    */
459    COINLIBAPI int COINLINKAGE
460    Cbc_perturbation(Cbc_Model * model)
461    ;
462    COINLIBAPI void COINLINKAGE
463    Cbc_setPerturbation(Cbc_Model * model, int value)
464    ;
465    /** Current (or last) algorithm */
466    COINLIBAPI int COINLINKAGE
467    Cbc_algorithm(Cbc_Model * model)
468    ;
469    /** Set algorithm */
470    COINLIBAPI void COINLINKAGE
471    Cbc_setAlgorithm(Cbc_Model * model, int value)
472    ;
473    /** Sum of dual infeasibilities */
474    COINLIBAPI double COINLINKAGE
475    Cbc_sumDualInfeasibilities(Cbc_Model * model)
476    ;
477    /** Number of dual infeasibilities */
478    COINLIBAPI int COINLINKAGE
479    Cbc_numberDualInfeasibilities(Cbc_Model * model)
480    ;
481    /** Sum of primal infeasibilities */
482    COINLIBAPI double COINLINKAGE
483    Cbc_sumPrimalInfeasibilities(Cbc_Model * model)
484    ;
485    /** Number of primal infeasibilities */
486    COINLIBAPI int COINLINKAGE
487    Cbc_numberPrimalInfeasibilities(Cbc_Model * model)
488    ;
489    /** Save model to file, returns 0 if success.  This is designed for
490        use outside algorithms so does not save iterating arrays etc.
491    It does not save any messaging information.
492    Does not save scaling values.
493    It does not know about all types of virtual functions.
494    */
495    COINLIBAPI int COINLINKAGE
496    Cbc_saveModel(Cbc_Model * model, const char * fileName)
497    ;
498    /** Restore model from file, returns 0 if success,
499        deletes current model */
500    COINLIBAPI int COINLINKAGE
501    Cbc_restoreModel(Cbc_Model * model, const char * fileName)
502    ;
503
504    /** Just check solution (for external use) - sets sum of
505        infeasibilities etc */
506    COINLIBAPI void COINLINKAGE
507    Cbc_checkSolution(Cbc_Model * model)
508    ;
509    /*@}*/
510
511    /******************** End of most useful part **************/
512    /**@name gets and sets - some synonyms */
513    /*@{*/
514    /** Number of rows */
515    COINLIBAPI int COINLINKAGE
516    Cbc_getNumRows(Cbc_Model * model)
517    ;
518    /** Number of columns */
519    COINLIBAPI int COINLINKAGE
520    Cbc_getNumCols(Cbc_Model * model)
521    ;
522    /** Number of iterations */
523    COINLIBAPI int COINLINKAGE
524    Cbc_getIterationCount(Cbc_Model * model)
525    ;
526    /** Are there a numerical difficulties? */
527    COINLIBAPI int COINLINKAGE
528    Cbc_isAbandoned(Cbc_Model * model)
529    ;
530    /** Is optimality proven? */
531    COINLIBAPI int COINLINKAGE
532    Cbc_isProvenOptimal(Cbc_Model * model)
533    ;
534    /** Is primal infeasiblity proven? */
535    COINLIBAPI int COINLINKAGE
536    Cbc_isProvenPrimalInfeasible(Cbc_Model * model)
537    ;
538    /** Is dual infeasiblity proven? */
539    COINLIBAPI int COINLINKAGE
540    Cbc_isProvenDualInfeasible(Cbc_Model * model)
541    ;
542    /** Is the given primal objective limit reached? */
543    COINLIBAPI int COINLINKAGE
544    Cbc_isPrimalObjectiveLimitReached(Cbc_Model * model)
545    ;
546    /** Is the given dual objective limit reached? */
547    COINLIBAPI int COINLINKAGE
548    Cbc_isDualObjectiveLimitReached(Cbc_Model * model)
549    ;
550    /** Iteration limit reached? */
551    COINLIBAPI int COINLINKAGE
552    Cbc_isIterationLimitReached(Cbc_Model * model)
553    ;
554    /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
555    COINLIBAPI double COINLINKAGE
556    Cbc_getObjSense(Cbc_Model * model)
557    ;
558    /** Primal row solution */
559    COINLIBAPI const double * COINLINKAGE
560    Cbc_getRowActivity(Cbc_Model * model)
561    ;
562    /** Primal column solution */
563    COINLIBAPI const double * COINLINKAGE
564    Cbc_getColSolution(Cbc_Model * model)
565    ;
566    COINLIBAPI void COINLINKAGE
567    Cbc_setColSolution(Cbc_Model * model, const double * input)
568    ;
569    /** Dual row solution */
570    COINLIBAPI const double * COINLINKAGE
571    Cbc_getRowPrice(Cbc_Model * model)
572    ;
573    /** Reduced costs */
574    COINLIBAPI const double * COINLINKAGE
575    Cbc_getReducedCost(Cbc_Model * model)
576    ;
577    /** Row lower */
578    COINLIBAPI const double* COINLINKAGE
579    Cbc_getRowLower(Cbc_Model * model)
580    ;
581    /** Row upper  */
582    COINLIBAPI const double* COINLINKAGE
583    Cbc_getRowUpper(Cbc_Model * model)
584    ;
585    /** Objective */
586    COINLIBAPI const double * COINLINKAGE
587    Cbc_getObjCoefficients(Cbc_Model * model)
588    ;
589    /** Column Lower */
590    COINLIBAPI const double * COINLINKAGE
591    Cbc_getColLower(Cbc_Model * model)
592    ;
593    /** Column Upper */
594    COINLIBAPI const double * COINLINKAGE
595    Cbc_getColUpper(Cbc_Model * model)
596    ;
597    /** Objective value */
598    COINLIBAPI double COINLINKAGE
599    Cbc_getObjValue(Cbc_Model * model)
600    ;
601    /** Print the model */
602    COINLIBAPI void COINLINKAGE
603    Cbc_printModel(Cbc_Model * model, const char * argPrefix)
604    ;
605    /** Determine whether the variable at location i is integer restricted */
606    COINLIBAPI int COINLINKAGE
607    Cbc_isInteger(Cbc_Model * model, int i)
608    ;
609    /** Return CPU time */
610    COINLIBAPI double COINLINKAGE
611    Cbc_cpuTime(Cbc_Model * model)
612    ;
613    /** Number of nodes explored in B&B tree */
614    COINLIBAPI int COINLINKAGE
615    Cbc_getNodeCount(Cbc_Model * model)
616    ;
617    /** Return a copy of this model */
618    COINLIBAPI Cbc_Model * COINLINKAGE
619    Cbc_clone(Cbc_Model * model)
620    ;
621    /** Set this the variable to be continuous */
622    COINLIBAPI Cbc_Model * COINLINKAGE
623    Cbc_setContinuous(Cbc_Model * model, int iColumn)
624    ;
625    /** Add SOS constraints to the model using dense matrix */
626    COINLIBAPI void  COINLINKAGE
627    Cbc_addSOS_Dense(Cbc_Model * model, int numObjects, const int * len,
628                     const int ** which, const double * weights, const int type)
629    ;
630    /** Add SOS constraints to the model using row-order matrix */
631    COINLIBAPI void  COINLINKAGE
632    Cbc_addSOS_Sparse(Cbc_Model * model, const int * rowStarts,
633                      const int * rowIndices, const double * weights, const int type)
634    ;
635    /** Delete all object information */
636    COINLIBAPI void  COINLINKAGE
637    Cbc_deleteObjects(Cbc_Model * model)
638    ;
639    /** Print the solution */
640    COINLIBAPI void  COINLINKAGE
641    Cbc_printSolution(Cbc_Model * model)
642    ;
643    /** Dual initial solve */
644    COINLIBAPI int COINLINKAGE
645    Cbc_initialDualSolve(Cbc_Model * model)
646    ;
647    /** Primal initial solve */
648    COINLIBAPI int COINLINKAGE
649    Cbc_initialPrimalSolve(Cbc_Model * model)
650    ;
651    /** Dual algorithm - see ClpSimplexDual.hpp for method */
652    COINLIBAPI int COINLINKAGE
653    Cbc_dual(Cbc_Model * model, int ifValuesPass)
654    ;
655    /** Primal algorithm - see ClpSimplexPrimal.hpp for method */
656    COINLIBAPI int COINLINKAGE
657    Cbc_primal(Cbc_Model * model, int ifValuesPass)
658    ;
659    /*@}*/
660#ifdef __cplusplus
661}
662#endif
663#endif
Note: See TracBrowser for help on using the repository browser.