source: stable/2.7/Cbc/src/Cbc_C_Interface.h @ 1783

Last change on this file since 1783 was 1675, checked in by stefan, 8 years ago

sync with trunk rev1674

  • 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 1675 2011-06-19 17:23:14Z stefan $ */
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.
178   
179      \p array must be a null-terminated string.
180    */
181    COINLIBAPI int COINLINKAGE
182    Cbc_setProblemName(Cbc_Model * model, int maxNumberCharacters, char * array)
183    ;
184    /** Number of iterations */
185    COINLIBAPI int COINLINKAGE
186    Cbc_numberIterations(Cbc_Model * model)
187    ;
188    COINLIBAPI void COINLINKAGE
189    Cbc_setNumberIterations(Cbc_Model * model, int numberIterations)
190    ;
191    /** Maximum number of iterations */
192    COINLIBAPI int COINLINKAGE
193    Cbc_maximumIterations(Cbc_Model * model)
194    ;
195    COINLIBAPI void COINLINKAGE
196    Cbc_setMaximumIterations(Cbc_Model * model, int value)
197    ;
198    /** Maximum number of nodes */
199    COINLIBAPI int COINLINKAGE
200    Cbc_maxNumNode(Cbc_Model * model)
201    ;
202    COINLIBAPI void COINLINKAGE
203    Cbc_setMaxNumNode(Cbc_Model * model, int value)
204    ;
205    /* Maximum number of solutions */
206    COINLIBAPI int COINLINKAGE
207    Cbc_maxNumSol(Cbc_Model * model)
208    ;
209    COINLIBAPI void COINLINKAGE
210    Cbc_setMaxNumSol(Cbc_Model * model, int value)
211    ;
212    /** Maximum time in seconds (from when set called) */
213    COINLIBAPI double COINLINKAGE
214    Cbc_maximumSeconds(Cbc_Model * model)
215    ;
216    COINLIBAPI void COINLINKAGE
217    Cbc_setMaximumSeconds(Cbc_Model * model, double value)
218    ;
219    /** Returns true if hit maximum iterations (or time) */
220    COINLIBAPI int COINLINKAGE
221    Cbc_hitMaximumIterations(Cbc_Model * model)
222    ;
223    /** Status of problem:
224        0 - optimal
225        1 - primal infeasible
226        2 - dual infeasible
227        3 - stopped on iterations etc
228        4 - stopped due to errors
229    */
230    COINLIBAPI int COINLINKAGE
231    Cbc_status(Cbc_Model * model)
232    ;
233    /** Set problem status */
234    COINLIBAPI void COINLINKAGE
235    Cbc_setProblemStatus(Cbc_Model * model, int problemStatus)
236    ;
237    /** Secondary status of problem - may get extended
238        0 - none
239        1 - primal infeasible because dual limit reached
240        2 - scaled problem optimal - unscaled has primal infeasibilities
241        3 - scaled problem optimal - unscaled has dual infeasibilities
242        4 - scaled problem optimal - unscaled has both dual and primal infeasibilities
243    */
244    COINLIBAPI int COINLINKAGE
245    Cbc_secondaryStatus(Cbc_Model * model)
246    ;
247    COINLIBAPI void COINLINKAGE
248    Cbc_setSecondaryStatus(Cbc_Model * model, int status)
249    ;
250    /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
251    COINLIBAPI double COINLINKAGE
252    Cbc_optimizationDirection(Cbc_Model * model)
253    ;
254    COINLIBAPI void COINLINKAGE
255    Cbc_setOptimizationDirection(Cbc_Model * model, double value)
256    ;
257    /** Primal row solution */
258    COINLIBAPI double * COINLINKAGE
259    Cbc_primalRowSolution(Cbc_Model * model)
260    ;
261    /** Primal column solution */
262    COINLIBAPI double * COINLINKAGE
263    Cbc_primalColumnSolution(Cbc_Model * model)
264    ;
265    /** Dual row solution */
266    COINLIBAPI double * COINLINKAGE
267    Cbc_dualRowSolution(Cbc_Model * model)
268    ;
269    /** Reduced costs */
270    COINLIBAPI double * COINLINKAGE
271    Cbc_dualColumnSolution(Cbc_Model * model)
272    ;
273    /** Row lower */
274    COINLIBAPI double* COINLINKAGE
275    Cbc_rowLower(Cbc_Model * model)
276    ;
277    /** Row upper  */
278    COINLIBAPI double* COINLINKAGE
279    Cbc_rowUpper(Cbc_Model * model)
280    ;
281    /** Objective */
282    COINLIBAPI double * COINLINKAGE
283    Cbc_objective(Cbc_Model * model)
284    ;
285    /** Column Lower */
286    COINLIBAPI double * COINLINKAGE
287    Cbc_columnLower(Cbc_Model * model)
288    ;
289    /** Column Upper */
290    COINLIBAPI double * COINLINKAGE
291    Cbc_columnUpper(Cbc_Model * model)
292    ;
293    /** Number of elements in matrix */
294    COINLIBAPI int COINLINKAGE
295    Cbc_getNumElements(Cbc_Model * model)
296    ;
297    /** Column starts in matrix */
298    COINLIBAPI const CoinBigIndex * COINLINKAGE
299    Cbc_getVectorStarts(Cbc_Model * model)
300    ;
301    /** Row indices in matrix */
302    COINLIBAPI const int * COINLINKAGE
303    Cbc_getIndices(Cbc_Model * model)
304    ;
305    /** Column vector lengths in matrix */
306    COINLIBAPI const int * COINLINKAGE
307    Cbc_getVectorLengths(Cbc_Model * model)
308    ;
309    /** Element values in matrix */
310    COINLIBAPI const double * COINLINKAGE
311    Cbc_getElements(Cbc_Model * model)
312    ;
313    /** Objective value */
314    COINLIBAPI double COINLINKAGE
315    Cbc_objectiveValue(Cbc_Model * model)
316    ;
317    /** Infeasibility/unbounded ray (NULL returned if none/wrong)
318        Up to user to use delete [] on these arrays.  */
319    COINLIBAPI double * COINLINKAGE
320    Cbc_infeasibilityRay(Cbc_Model * model)
321    ;
322    COINLIBAPI double * COINLINKAGE
323    Cbc_unboundedRay(Cbc_Model * model)
324    ;
325    /** See if status array exists (partly for OsiClp) */
326    COINLIBAPI int COINLINKAGE
327    Cbc_statusExists(Cbc_Model * model)
328    ;
329    /** Return address of status array (char[numberRows+numberColumns]) */
330    COINLIBAPI void  COINLINKAGE
331    Cbc_getBasisStatus(Cbc_Model * model, int * cstat, int * rstat)
332    ;
333    /** Copy in status vector */
334    COINLIBAPI void COINLINKAGE
335    Cbc_setBasisStatus(Cbc_Model * model, int * cstat, int * rstat)
336    ;
337
338    /** User pointer for whatever reason */
339    COINLIBAPI void COINLINKAGE
340    Cbc_setUserPointer (Cbc_Model * model, void * pointer)
341    ;
342    COINLIBAPI void * COINLINKAGE
343    Cbc_getUserPointer (Cbc_Model * model)
344    ;
345    /*@}*/
346    /**@name Message handling.  Call backs are handled by ONE function */
347    /*@{*/
348    /** Pass in Callback function.
349     Message numbers up to 1000000 are Clp, Coin ones have 1000000 added */
350    COINLIBAPI void COINLINKAGE
351    Cbc_registerCallBack(Cbc_Model * model,
352                         cbc_callback userCallBack)
353    ;
354    /** Unset Callback function */
355    COINLIBAPI void COINLINKAGE
356    Cbc_clearCallBack(Cbc_Model * model)
357    ;
358    /** Amount of print out:
359        0 - none
360        1 - just final
361        2 - just factorizations
362        3 - as 2 plus a bit more
363        4 - verbose
364        above that 8,16,32 etc just for selective debug
365    */
366    COINLIBAPI void COINLINKAGE
367    Cbc_setLogLevel(Cbc_Model * model, int value)
368    ;
369    COINLIBAPI int COINLINKAGE
370    Cbc_logLevel(Cbc_Model * model)
371    ;
372    /** length of names (0 means no names0 */
373    COINLIBAPI int COINLINKAGE
374    Cbc_lengthNames(Cbc_Model * model)
375    ;
376    /** Fill in array (at least lengthNames+1 long) with a row name */
377    COINLIBAPI void COINLINKAGE
378    Cbc_rowName(Cbc_Model * model, int iRow, char * name)
379    ;
380    /** Fill in array (at least lengthNames+1 long) with a column name */
381    COINLIBAPI void COINLINKAGE
382    Cbc_columnName(Cbc_Model * model, int iColumn, char * name)
383    ;
384
385    /*@}*/
386
387
388    /**@name Functions most useful to user */
389    /*@{*/
390    /** General solve algorithm which can do presolve.
391        See  ClpSolve.hpp for options
392     */
393    COINLIBAPI int COINLINKAGE
394    Cbc_initialSolve(Cbc_Model * model)
395    ;
396    /* General solve algorithm which can do presolve.
397       See  CbcModel.hpp for options
398    */
399    COINLIBAPI int COINLINKAGE
400    Cbc_branchAndBound(Cbc_Model * model)
401    ;
402    /** Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) */
403    COINLIBAPI void COINLINKAGE
404    Cbc_scaling(Cbc_Model * model, int mode)
405    ;
406    /** Gets scalingFlag */
407    COINLIBAPI int COINLINKAGE
408    Cbc_scalingFlag(Cbc_Model * model)
409    ;
410    /** Crash - at present just aimed at dual, returns
411        -2 if dual preferred and crash basis created
412        -1 if dual preferred and all slack basis preferred
413         0 if basis going in was not all slack
414         1 if primal preferred and all slack basis preferred
415         2 if primal preferred and crash basis created.
416
417         if gap between bounds <="gap" variables can be flipped
418
419         If "pivot" is
420         0 No pivoting (so will just be choice of algorithm)
421         1 Simple pivoting e.g. gub
422         2 Mini iterations
423    */
424    COINLIBAPI int COINLINKAGE
425    Cbc_crash(Cbc_Model * model, double gap, int pivot)
426    ;
427    /*@}*/
428
429
430    /**@name most useful gets and sets */
431    /*@{*/
432    /** If problem is primal feasible */
433    COINLIBAPI int COINLINKAGE
434    Cbc_primalFeasible(Cbc_Model * model)
435    ;
436    /** If problem is dual feasible */
437    COINLIBAPI int COINLINKAGE
438    Cbc_dualFeasible(Cbc_Model * model)
439    ;
440    /** Dual bound */
441    COINLIBAPI double COINLINKAGE
442    Cbc_dualBound(Cbc_Model * model)
443    ;
444    COINLIBAPI void COINLINKAGE
445    Cbc_setDualBound(Cbc_Model * model, double value)
446    ;
447    /** Infeasibility cost */
448    COINLIBAPI double COINLINKAGE
449    Cbc_infeasibilityCost(Cbc_Model * model)
450    ;
451    COINLIBAPI void COINLINKAGE
452    Cbc_setInfeasibilityCost(Cbc_Model * model, double value)
453    ;
454    /** Perturbation:
455        50  - switch on perturbation
456        100 - auto perturb if takes too long (1.0e-6 largest nonzero)
457        101 - we are perturbed
458        102 - don't try perturbing again
459        default is 100
460        others are for playing
461    */
462    COINLIBAPI int COINLINKAGE
463    Cbc_perturbation(Cbc_Model * model)
464    ;
465    COINLIBAPI void COINLINKAGE
466    Cbc_setPerturbation(Cbc_Model * model, int value)
467    ;
468    /** Current (or last) algorithm */
469    COINLIBAPI int COINLINKAGE
470    Cbc_algorithm(Cbc_Model * model)
471    ;
472    /** Set algorithm */
473    COINLIBAPI void COINLINKAGE
474    Cbc_setAlgorithm(Cbc_Model * model, int value)
475    ;
476    /** Sum of dual infeasibilities */
477    COINLIBAPI double COINLINKAGE
478    Cbc_sumDualInfeasibilities(Cbc_Model * model)
479    ;
480    /** Number of dual infeasibilities */
481    COINLIBAPI int COINLINKAGE
482    Cbc_numberDualInfeasibilities(Cbc_Model * model)
483    ;
484    /** Sum of primal infeasibilities */
485    COINLIBAPI double COINLINKAGE
486    Cbc_sumPrimalInfeasibilities(Cbc_Model * model)
487    ;
488    /** Number of primal infeasibilities */
489    COINLIBAPI int COINLINKAGE
490    Cbc_numberPrimalInfeasibilities(Cbc_Model * model)
491    ;
492    /** Save model to file, returns 0 if success.  This is designed for
493        use outside algorithms so does not save iterating arrays etc.
494    It does not save any messaging information.
495    Does not save scaling values.
496    It does not know about all types of virtual functions.
497    */
498    COINLIBAPI int COINLINKAGE
499    Cbc_saveModel(Cbc_Model * model, const char * fileName)
500    ;
501    /** Restore model from file, returns 0 if success,
502        deletes current model */
503    COINLIBAPI int COINLINKAGE
504    Cbc_restoreModel(Cbc_Model * model, const char * fileName)
505    ;
506
507    /** Just check solution (for external use) - sets sum of
508        infeasibilities etc */
509    COINLIBAPI void COINLINKAGE
510    Cbc_checkSolution(Cbc_Model * model)
511    ;
512    /*@}*/
513
514    /******************** End of most useful part **************/
515    /**@name gets and sets - some synonyms */
516    /*@{*/
517    /** Number of rows */
518    COINLIBAPI int COINLINKAGE
519    Cbc_getNumRows(Cbc_Model * model)
520    ;
521    /** Number of columns */
522    COINLIBAPI int COINLINKAGE
523    Cbc_getNumCols(Cbc_Model * model)
524    ;
525    /** Number of iterations */
526    COINLIBAPI int COINLINKAGE
527    Cbc_getIterationCount(Cbc_Model * model)
528    ;
529    /** Are there a numerical difficulties? */
530    COINLIBAPI int COINLINKAGE
531    Cbc_isAbandoned(Cbc_Model * model)
532    ;
533    /** Is optimality proven? */
534    COINLIBAPI int COINLINKAGE
535    Cbc_isProvenOptimal(Cbc_Model * model)
536    ;
537    /** Is primal infeasiblity proven? */
538    COINLIBAPI int COINLINKAGE
539    Cbc_isProvenPrimalInfeasible(Cbc_Model * model)
540    ;
541    /** Is dual infeasiblity proven? */
542    COINLIBAPI int COINLINKAGE
543    Cbc_isProvenDualInfeasible(Cbc_Model * model)
544    ;
545    /** Is the given primal objective limit reached? */
546    COINLIBAPI int COINLINKAGE
547    Cbc_isPrimalObjectiveLimitReached(Cbc_Model * model)
548    ;
549    /** Is the given dual objective limit reached? */
550    COINLIBAPI int COINLINKAGE
551    Cbc_isDualObjectiveLimitReached(Cbc_Model * model)
552    ;
553    /** Iteration limit reached? */
554    COINLIBAPI int COINLINKAGE
555    Cbc_isIterationLimitReached(Cbc_Model * model)
556    ;
557    /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
558    COINLIBAPI double COINLINKAGE
559    Cbc_getObjSense(Cbc_Model * model)
560    ;
561    /** Primal row solution */
562    COINLIBAPI const double * COINLINKAGE
563    Cbc_getRowActivity(Cbc_Model * model)
564    ;
565    /** Primal column solution */
566    COINLIBAPI const double * COINLINKAGE
567    Cbc_getColSolution(Cbc_Model * model)
568    ;
569    COINLIBAPI void COINLINKAGE
570    Cbc_setColSolution(Cbc_Model * model, const double * input)
571    ;
572    /** Dual row solution */
573    COINLIBAPI const double * COINLINKAGE
574    Cbc_getRowPrice(Cbc_Model * model)
575    ;
576    /** Reduced costs */
577    COINLIBAPI const double * COINLINKAGE
578    Cbc_getReducedCost(Cbc_Model * model)
579    ;
580    /** Row lower */
581    COINLIBAPI const double* COINLINKAGE
582    Cbc_getRowLower(Cbc_Model * model)
583    ;
584    /** Row upper  */
585    COINLIBAPI const double* COINLINKAGE
586    Cbc_getRowUpper(Cbc_Model * model)
587    ;
588    /** Objective */
589    COINLIBAPI const double * COINLINKAGE
590    Cbc_getObjCoefficients(Cbc_Model * model)
591    ;
592    /** Column Lower */
593    COINLIBAPI const double * COINLINKAGE
594    Cbc_getColLower(Cbc_Model * model)
595    ;
596    /** Column Upper */
597    COINLIBAPI const double * COINLINKAGE
598    Cbc_getColUpper(Cbc_Model * model)
599    ;
600    /** Objective value */
601    COINLIBAPI double COINLINKAGE
602    Cbc_getObjValue(Cbc_Model * model)
603    ;
604    /** Print the model */
605    COINLIBAPI void COINLINKAGE
606    Cbc_printModel(Cbc_Model * model, const char * argPrefix)
607    ;
608    /** Determine whether the variable at location i is integer restricted */
609    COINLIBAPI int COINLINKAGE
610    Cbc_isInteger(Cbc_Model * model, int i)
611    ;
612    /** Return CPU time */
613    COINLIBAPI double COINLINKAGE
614    Cbc_cpuTime(Cbc_Model * model)
615    ;
616    /** Number of nodes explored in B&B tree */
617    COINLIBAPI int COINLINKAGE
618    Cbc_getNodeCount(Cbc_Model * model)
619    ;
620    /** Return a copy of this model */
621    COINLIBAPI Cbc_Model * COINLINKAGE
622    Cbc_clone(Cbc_Model * model)
623    ;
624    /** Set this the variable to be continuous */
625    COINLIBAPI Cbc_Model * COINLINKAGE
626    Cbc_setContinuous(Cbc_Model * model, int iColumn)
627    ;
628    /** Add SOS constraints to the model using dense matrix */
629    COINLIBAPI void  COINLINKAGE
630    Cbc_addSOS_Dense(Cbc_Model * model, int numObjects, const int * len,
631                     const int ** which, const double * weights, const int type)
632    ;
633    /** Add SOS constraints to the model using row-order matrix */
634    COINLIBAPI void  COINLINKAGE
635    Cbc_addSOS_Sparse(Cbc_Model * model, const int * rowStarts,
636                      const int * rowIndices, const double * weights, const int type)
637    ;
638    /** Delete all object information */
639    COINLIBAPI void  COINLINKAGE
640    Cbc_deleteObjects(Cbc_Model * model)
641    ;
642    /** Print the solution */
643    COINLIBAPI void  COINLINKAGE
644    Cbc_printSolution(Cbc_Model * model)
645    ;
646    /** Dual initial solve */
647    COINLIBAPI int COINLINKAGE
648    Cbc_initialDualSolve(Cbc_Model * model)
649    ;
650    /** Primal initial solve */
651    COINLIBAPI int COINLINKAGE
652    Cbc_initialPrimalSolve(Cbc_Model * model)
653    ;
654    /** Dual algorithm - see ClpSimplexDual.hpp for method */
655    COINLIBAPI int COINLINKAGE
656    Cbc_dual(Cbc_Model * model, int ifValuesPass)
657    ;
658    /** Primal algorithm - see ClpSimplexPrimal.hpp for method */
659    COINLIBAPI int COINLINKAGE
660    Cbc_primal(Cbc_Model * model, int ifValuesPass)
661    ;
662    /*@}*/
663#ifdef __cplusplus
664}
665#endif
666#endif
Note: See TracBrowser for help on using the repository browser.